Library: XyText v1.0 -- llSetText Alternative

XyText uses images accessed by UUID for the letters.
1.0.x uses 2 letters per prim face
1.1.x uses 1 letter per prim face

with 1.0.x every 2 letter combination of letters had to be mapped. This required the creation of 66 textures.
1.1.x only places one letter per face so it was able to do this with one texture.

XyText does not support Unicode at present
1.1.x uses 100 characters per texture.
full Unicode support is about 62,981 glyphs (characters)
thats 630 images that would need to be made and uploaded.
if you wanted to use 2 character support (1.0.x) then that would be about 2 billion character pairs or 20 million textures.

Its just uses texture offsets so it does not have Unicode (that's what it's called) support.

I would think with the new 1.6 version, you could now stream in a "Text" file into Quicktime with the characters you wanted to display. I understand this is a feature thats built into Quicktime, and its low bandwitdh (unlike streaming real high res, with sound video).

Do some searches on the forums, I think they have some descriptions of how to accomplish this, I just read it a few days ago but unsure how it works yet (gonna play with it as soon as I can get in the world, couldnt login last night )

I assume that if you have multiple things to display you do need different sets of linked prims here. That is the communications between parts of a board will likely have to use llSay as the mechanism as you can't LINK everything. Is this correct?

BTW - This is a great package. Thanks for posting.

i use integers in linked messages so if cellset one is names it will only respond to num 99 and the scores cellset use lets say 42

I've trialled using v1.0 (2 letters per prim face) but it does take 5-10 seconds for me for a new string (say 20-30 characters) to appear properly. Is this the type of performance people are seeing with v1.0

Given this I think I'll go to v1.1 and try this (uses more prims is the only downside I assume ??)

In summary I guess I'm interested in determining whether refresh rate issue I'm having with v1.0 is expected or not (e.g. it's not just an issue with my PC and rendering?)

cheers
Greg

I'm seeing response times of 5-20 seconds in rendering 20-30 chars of text with v1.0 (2 chars per face). Is this normal? (i.e. not a problem with my PC is it)

If yes, I should try v1.1 I guess - I assume the only negative with this version (1 char per face) is that it will require more prims (but be faster rendering)?

Tks

Updated version of XyText created as a result of this thread. Turns out there's a way to shape a cube to get 5 equal sized faces for text display on just one prim. This means we can now display 5 characters with one prim instead of 3

This script is designed to work with a prim shaped as described here.

////////////////////////////////////////////
// XyText v1.2 Script (5 Face, Single Texture)
//
// Written by Xylor Baysklef
//
// Modified by Kermitt Quirk 19/01/2006
// To add support for 5 face prim instead of 3
//
////////////////////////////////////////////

/////////////// CONSTANTS ///////////////////
// XyText Message Map.
integer DISPLAY_STRING      = 204000;
integer DISPLAY_EXTENDED    = 204001;
integer REMAP_INDICES       = 204002;
integer RESET_INDICES       = 204003;
integer SET_CELL_INFO       = 204004;
integer SET_FONT_TEXTURE    = 204005;
integer SET_THICKNESS       = 204006;
integer SET_COLOR           = 204007;

// This is an extended character escape sequence.
string  ESCAPE_SEQUENCE = "\\e";

// This is used to get an index for the extended character.
string  EXTENDED_INDEX  = "12345";

// Face numbers.
integer FACE_1          = 3;
integer FACE_2          = 7;
integer FACE_3          = 4;
integer FACE_4          = 6;
integer FACE_5          = 1;

// Used to hide the text after a fade-out.
key     TRANSPARENT     = "701917a8-d614-471f-13dd-5f4644e36e3c";
///////////// END CONSTANTS ////////////////

///////////// GLOBAL VARIABLES ///////////////
// This is the key of the font we are displaying.
key     gFontTexture        = "b2e7394f-5e54-aa12-6e1c-ef327b6bed9e";
// All displayable characters.  Default to ASCII order.
string gCharIndex;
// This is the channel to listen on while acting
// as a cell in a larger display.
integer gCellChannel        = -1;
// This is the starting character position in the cell channel message
// to render.
integer gCellCharPosition   = 0;
// This is whether or not to use the fade in/out special effect.
integer gCellUseFading      = FALSE;
// This is how long to display the text before fading out (if using
// fading special effect).
// Note: < 0  means don't fade out.
float   gCellHoldDelay      = 1.0;
/////////// END GLOBAL VARIABLES ////////////

ResetCharIndex() {
   gCharIndex  = " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`";
   // \" <-- Fixes LSL syntax highlighting bug.
   gCharIndex += "abcdefghijklmnopqrstuvwxyz{|}~";
   gCharIndex += "\n\n\n\n\n";
}

vector GetGridOffset(integer index) {
   // Calculate the offset needed to display this character.
   integer Row = index / 10;
   integer Col = index % 10;

   // Return the offset in the texture.
   return <-0.45 + 0.1 * Col, 0.45 - 0.1 * Row, 0.0>;
}

ShowChars(vector grid_offset1, vector grid_offset2, vector grid_offset3, vector grid_offset4, vector grid_offset5) {
   // Set the primitive textures directly.
   
   // <-0.256, 0, 0>
   // <0, 0, 0>
   // <0.130, 0, 0>
   // <0, 0, 0>
   // <-0.74, 0, 0>
   
   llSetPrimitiveParams( [
        PRIM_TEXTURE, FACE_1, (string)gFontTexture, <0.12, 0.1, 0>, grid_offset1 + <0.037, 0, 0>, 0.0,
        PRIM_TEXTURE, FACE_2, (string)gFontTexture, <0.05, 0.1, 0>, grid_offset2, 0.0,
        PRIM_TEXTURE, FACE_3, (string)gFontTexture, <-0.74, 0.1, 0>, grid_offset3 - <0.244, 0, 0>, 0.0,
        PRIM_TEXTURE, FACE_4, (string)gFontTexture, <0.05, 0.1, 0>, grid_offset4, 0.0,
        PRIM_TEXTURE, FACE_5, (string)gFontTexture, <0.12, 0.1, 0>, grid_offset5 - <0.037, 0, 0>, 0.0
        ]);
}

RenderString(string str) {
   // Get the grid positions for each pair of characters.
   vector GridOffset1 = GetGridOffset( llSubStringIndex(gCharIndex, llGetSubString(str, 0, 0)) );
   vector GridOffset2 = GetGridOffset( llSubStringIndex(gCharIndex, llGetSubString(str, 1, 1)) );
   vector GridOffset3 = GetGridOffset( llSubStringIndex(gCharIndex, llGetSubString(str, 2, 2)) );
   vector GridOffset4 = GetGridOffset( llSubStringIndex(gCharIndex, llGetSubString(str, 3, 3)) );
   vector GridOffset5 = GetGridOffset( llSubStringIndex(gCharIndex, llGetSubString(str, 4, 4)) );

   // Use these grid positions to display the correct textures/offsets.
   ShowChars(GridOffset1, GridOffset2, GridOffset3, GridOffset4, GridOffset5);
}

RenderWithEffects(string str) {
   // Get the grid positions for each pair of characters.
   vector GridOffset1 = GetGridOffset( llSubStringIndex(gCharIndex, llGetSubString(str, 0, 0)) );
   vector GridOffset2 = GetGridOffset( llSubStringIndex(gCharIndex, llGetSubString(str, 1, 1)) );
   vector GridOffset3 = GetGridOffset( llSubStringIndex(gCharIndex, llGetSubString(str, 2, 2)) );
   vector GridOffset4 = GetGridOffset( llSubStringIndex(gCharIndex, llGetSubString(str, 3, 3)) );
   vector GridOffset5 = GetGridOffset( llSubStringIndex(gCharIndex, llGetSubString(str, 4, 4)) );

   // First set the alpha to the lowest possible.
   llSetAlpha(0.05, ALL_SIDES);

   // Use these grid positions to display the correct textures/offsets.
   ShowChars(GridOffset1, GridOffset2, GridOffset3, GridOffset4, GridOffset5);          // Now turn up the alpha until it is at full strength.
    float Alpha;
    for (Alpha = 0.10; Alpha <= 1.0; Alpha += 0.05)
       llSetAlpha(Alpha, ALL_SIDES);
          // See if we want to fade out as well.
   if (gCellHoldDelay < 0.0)
       // No, bail out. (Just keep showing the string at full strength).
       return;
          // Hold the text for a while.
   llSleep(gCellHoldDelay);
      // Now fade out.
   for (Alpha = 0.95; Alpha >= 0.05; Alpha -= 0.05)
       llSetAlpha(Alpha, ALL_SIDES);
          // Make the text transparent to fully hide it.
   llSetTexture(TRANSPARENT, ALL_SIDES);
}

RenderExtended(string str) {
   // Look for escape sequences.
   list Parsed       = llParseString2List(str, [], [ESCAPE_SEQUENCE]);
   integer ParsedLen = llGetListLength(Parsed);

   // Create a list of index values to work with.
   list Indices;
   // We start with room for 5 indices.
   integer IndicesLeft = 5;

   integer i;
   string Token;
   integer Clipped;
   integer LastWasEscapeSequence = FALSE;
   // Work from left to right.
   for (i = 0; i < ParsedLen && IndicesLeft > 0; i++) {
       Token = llList2String(Parsed, i);

       // If this is an escape sequence, just set the flag and move on.
       if (Token == ESCAPE_SEQUENCE) {
           LastWasEscapeSequence = TRUE;
       }
       else { // Token != ESCAPE_SEQUENCE
           // Otherwise this is a normal token.  Check its length.
           Clipped = FALSE;
           integer TokenLength = llStringLength(Token);
           // Clip if necessary.
           if (TokenLength > IndicesLeft) {
               Token = llGetSubString(Token, 0, IndicesLeft - 1);
               TokenLength = llStringLength(Token);
               IndicesLeft = 0;
               Clipped = TRUE;
           }
           else
               IndicesLeft -= TokenLength;

           // Was the previous token an escape sequence?
           if (LastWasEscapeSequence) {
               // Yes, the first character is an escape character, the rest are normal.

               // This is the extended character.
               Indices += [llSubStringIndex(EXTENDED_INDEX, llGetSubString(Token, 0, 0)) + 95];

               // These are the normal characters.
               integer j;
               for (j = 1; j < TokenLength; j++)
                   Indices += [llSubStringIndex(gCharIndex, llGetSubString(Token, j, j))];
           }
           else { // Normal string.
               // Just add the characters normally.
               integer j;
               for (j = 0; j < TokenLength; j++)
                   Indices += [llSubStringIndex(gCharIndex, llGetSubString(Token, j, j))];
           }

           // Unset this flag, since this was not an escape sequence.
           LastWasEscapeSequence = FALSE;
       }
   }

   // Use the indices to create grid positions.
   vector GridOffset1 = GetGridOffset( llList2Integer(Indices, 0));
   vector GridOffset2 = GetGridOffset( llList2Integer(Indices, 1) );
   vector GridOffset3 = GetGridOffset( llList2Integer(Indices, 2) );
   vector GridOffset4 = GetGridOffset( llList2Integer(Indices, 3) );
   vector GridOffset5 = GetGridOffset( llList2Integer(Indices, 4) );

   // Use these grid positions to display the correct textures/offsets.
   ShowChars(GridOffset1, GridOffset2, GridOffset3, GridOffset4, GridOffset5);
}

integer ConvertIndex(integer index) {
   // This converts from an ASCII based index to our indexing scheme.
   if (index >= 32) // ' ' or higher
       index -= 32;
   else { // index < 32
       // Quick bounds check.
       if (index > 15)
           index = 15;

       index += 94; // extended characters
   }

   return index;
}

default {
   state_entry() {
       // Initialize the character index.
       ResetCharIndex();
   }

   link_message(integer sender, integer channel, string data, key id) {
       if (channel == DISPLAY_STRING) {
           RenderString(data);
           return;
       }
       if (channel == DISPLAY_EXTENDED) {
           RenderExtended(data);
           return;
       }
       if (channel == gCellChannel) {
           // Extract the characters we are interested in, and use those to render.
           string TextToRender = llGetSubString(data, gCellCharPosition, gCellCharPosition + 4);
                      // See if we need to show special effects.
           if (gCellUseFading)
               RenderWithEffects( TextToRender );
           else // !gCellUseFading
               RenderString( TextToRender );
           return;
       }
       if (channel == REMAP_INDICES) {
           // Parse the message, splitting it up into index values.
           list Parsed = llCSV2List(data);
           integer i;
           // Go through the list and swap each pair of indices.
           for (i = 0; i < llGetListLength(Parsed); i += 2) {
               integer Index1 = ConvertIndex( llList2Integer(Parsed, i) );
               integer Index2 = ConvertIndex( llList2Integer(Parsed, i + 1) );

               // Swap these index values.
               string Value1 = llGetSubString(gCharIndex, Index1, Index1);
               string Value2 = llGetSubString(gCharIndex, Index2, Index2);

               gCharIndex = llDeleteSubString(gCharIndex, Index1, Index1);
               gCharIndex = llInsertString(gCharIndex, Index1, Value2);

               gCharIndex = llDeleteSubString(gCharIndex, Index2, Index2);
               gCharIndex = llInsertString(gCharIndex, Index2, Value1);
           }
           return;
       }
       if (channel == RESET_INDICES) {
           // Restore the character index back to default settings.
           ResetCharIndex();
           return;
       }
       if (channel == SET_CELL_INFO) {
           // Change the channel we listen to for cell commands, the
           // starting character position to extract from, and
           // special effect attributes.
           list Parsed = llCSV2List(data);
           gCellChannel        = (integer) llList2String(Parsed, 0);
           gCellCharPosition   = (integer) llList2String(Parsed, 1);
           gCellUseFading      = (integer) llList2String(Parsed, 2);
           gCellHoldDelay      = (float)   llList2String(Parsed, 3);
           return;
       }
       if (channel == SET_FONT_TEXTURE) {
           // Use the new texture instead of the current one.
           gFontTexture = id;
           // Change the currently shown texture.
           llSetTexture(gFontTexture, FACE_1);
           llSetTexture(gFontTexture, FACE_2);
           llSetTexture(gFontTexture, FACE_3);
           llSetTexture(gFontTexture, FACE_4);
           llSetTexture(gFontTexture, FACE_5);
           return;
       }
       if (channel == SET_THICKNESS) {
           // Set our z scale to thickness, while staying fixed
           // in position relative the prim below us.
           vector Scale    = llGetScale();
           float Thickness = (float) data;
                      // Reposition only if this isn't the root prim.
           integer ThisLink = llGetLinkNumber();
           if (ThisLink != 0 || ThisLink != 1) {
               // This is not the root prim.
               vector Up = llRot2Up(llGetLocalRot());
               float DistanceToMove = Thickness / 2.0 - Scale.z / 2.0;
               vector Pos = llGetLocalPos();
               llSetPos(Pos + DistanceToMove * Up);
           }
                      // Apply the new thickness.
           Scale.z = Thickness;
           llSetScale(Scale);
           return;
       }
       if (channel == SET_COLOR) {
           vector newColor = (vector)data;
           llSetColor(newColor, ALL_SIDES);
       }
   }
}

Kermit...I love the 5 faces...but the original XYText displayed 6 characters on 3 faces...so wouldn't it make sense to display 10 characters on those 5 faces...instead of 5 (which is less than the original)?

Personal preference really. I only used 3 chars on the original one. Mainly because I just don't like the rendering delays caused by having to utilise so many textures to display 2 chars per face. Thraxis Epsilon has created a 10 char version back in the original thread that triggered this. Here's a link to the post...
/54/d7/82725/1.html#post853425

I use the "5 faces per prim/1 char per face" verison too - the rendering time is most important to me as I want to display status text that changes every few seconds - its still not perfect but better than the configuration where there are 2 char per face

Oh..so..hmm...i'm having the hardest time making my own texture for this. I'm using the 5 face, one character per face deal so I've only got one texture to deal with. Does anyone have any tips on how this texture is made to be completely divisible by 10 both ways? Is there a simple way of editing to the script to add 5 more characters? I'm willing to help people make versions in more languages?

I had similar problems. I have decided to change the script, as I need way more than the original 100 characters. I've not finished it yet, when I have, I'll post the modified version and further details.

I just took a class at ^ASL^ on using XYtext to make a signboard with multiple XYtext cells. Setting up the board made me think of an easier way to configure the cells.

Instead of changing the value of the global variable in line 116:
integer gCellCharPosition = 0;
to the next chunk of characters to display, I added a line to the linked_message section. The first line of my linked_message section now reads:

gCellCharPosition=10 * (integer) llGetObjectDesc()

With that, I simply have to put a number in the description field of each cell. I don't have to pay attention to the order of linking the cells (other than the root) and I don't have to go hunting through the code to find line 116 to change the value of gCellCharPosition.

Where can I get the XyText Notecard Reader? Searches on LSLWiki, Linden Wiki, SLB SLEX and even asking in the scripters group turn up nothing. Please send one to Robbie Riptide if you have it

I have played around a lot with xytext, and i have written scripts to read notecards, but i don't pretend to have the best implementation around. I have a stupid script to read the first n lines of a notecard and throw it in an xytext display, but i have seen numerous commercial implementations that let you mix text and graphics, for instance. Would a (simple) script be about what you are looking for here?

The thing I still cannot get it to do (and I know I'm missing something obvious) is to chain two of these together and have more than 10 characters on the display.

*goes and pokes the script some more*

I took a look at the texture mentioned earlier in this thread (b2e7394f-5e54-aa12-6e1c-ef327b6bed9e), and it *looks* relatively simple to do. You can render the texture with a simple script, and I recommend rendering another solid-texture object right behind that b/c the font texture is all transparent except for the actual characters.

However, there is at least one error in this texture. According to the gCharIndex variable, right after "xyz" should be "{|}". But the texture shows "{|0" instead. So no closing curly brace for us, I guess.

I'm especially interested in whether there's a Monaco and/or Silkscreen version of this texture out there. Anyone know?

I don't have the script in front of me, but look for something like "SET CELL INFO". This message would set a channel for it to listen to for text to display and the part of the text for it to show. So you would send this to the first prim to say "receive text from channel 1234, start at 0" and the second prim to say "receive text from channel 1234, start at 10". Once you have this set up you can set an entire line of text with a single llMessageLinked.

That'#s the original single character texture, and it is indeed missing a right brace. There is another version of it, with the right brace (and I think a couple other characters) fixed. I've only just got my computer running so don't have the reference to hand just now.

Ok, now I’m really not getting what is exactly going on with the post. I tried the XyText v1.2 (5 Face, Single Texture) placed that script in the prim shaped from the [82618] post.

When I do this I have a longish-tan tile (assuming this is the multi faced prim). I copied the prim in a row of four and then dropped a little lower and made another *row* of the same prims. I was hoping to make a board that would read from a note card
After that I’m lost in where to put a note card reader. Do I make another prim as the back board and link and insert the notecard reader there? Am I making this more difficult than it really is?
I also tried the ones on wiki as well…. Still at a loss on what’s happening.

Would love to contact you in-world if I can help you get this setup. It sounds like you're pretty much on the right path though. All communication is done via llMessageLinked commands, the wiki is a bit short on documentation on multi-prim boards though. With XyText you need to notify each prim to tell it where in the board it exists in, after which a single llMessageLinked call will set each line of text.

There is also a newer XyzzyText script that has been put out that reduces the number of scripts required to get a multi-prim board working. The two scripts are nearly identical other than that though, and if you are familiar with XyText it shouldn't be that difficult to switch between them.

Hi, is there any PhotoShop script (ot other) technique for generating other fonts textures? especially for the 1 face x char version it should be very easy to implement, I think I already did see something like that, but I lost the link
Thanks for any advice.

I see in the example for Xyzzy that it alternates between updating the top or second line of prims - which is working fine for me. What I can't figure out is how to extend a longer sentence over the two lines so that when line one is full, the text flows to line two, then three, for example.

Any hints, please?

Thanks in advance,

DG

////////////////////////////////////////////
// XyText Prim Setup
//
// Written by Xylor Baysklef
////////////////////////////////////////////

/////////////// CONSTANTS ///////////////////
// Transparent texture key.
string TRANSPARENT = "701917a8-d614-471f-13dd-5f4644e36e3c";

default {
state_entry() {
// Set up the prim to be the correct shape.
vector Scale = llGetScale();
llSetPrimitiveParams([
// Set the top size so this shows 3 faces at once.
PRIM_TYPE, PRIM_TYPE_BOX, PRIM_HOLE_DEFAULT, <0, 1, 0>, 0.0,
<0.0, 0.0, 0.0>, <0.333333, 1, 0>, ZERO_VECTOR,

// Display the string "XyText" for now.
PRIM_TEXTURE, 4, "0e47c89e-de4a-6233-a2da-cb852aad1b00",
<0.1, 0.1, 0>, <0.200000, -0.450000, 0.000000>, PI_BY_TWO,

PRIM_TEXTURE, 0, "20b24b3a-8c57-82ee-c6ed-555003f5dbcd",
<0.1, 0.1, 0>, <-0.200000, -0.450000, 0.000000>, 0.0,

PRIM_TEXTURE, 2, "2f713216-4e71-d123-03ed-9c8554710c6b",
<0.1, 0.1, 0>, <-0.050000, -0.350000, 0.000000>, -PI_BY_TWO,

// Show transparent textures for the other sides.
PRIM_TEXTURE, 1, TRANSPARENT, <0.1, 0.1, 0>, ZERO_VECTOR, 0.0,
PRIM_TEXTURE, 3, TRANSPARENT, <0.1, 0.1, 0>, ZERO_VECTOR, 0.0,
PRIM_TEXTURE, 5, TRANSPARENT, <0.1, 0.1, 0>, ZERO_VECTOR, 0.0,

// Set the correct aspect ratio.
PRIM_SIZE, <Scale.x, Scale.x / 3, 0.01>
]);

// Remove ourselves from inventory.
llRemoveInventory(llGetScriptName());
}
}