3D font rendering and text layout engine for the web
SDF-based text rendering for Three.js
3D text rendering, backed by troika-three-text
Render text in 3D using Signed Distance Fields
SDF-based text rendering for Three.js
Render text in 3D using Signed Distance Fields
Signed distance fields (SDF) text rendering, using [troika-three-text](https://github.com/protectwise/troika/tree/main/packages/troika-three-text).
Renders BMFont files in ThreeJS with word-wrapping
A JavaScript text diff implementation.
Various utilities related to Three.js
A sprite based text component for ThreeJS
A texture with the drawn text.
ThreeJS geometry for drawing polygons on a sphere
A BVH implementation to speed up raycasting against three.js meshes.
JavaScript 3D library
Easy way to render ThreeJS objects with built-in interaction defaults
A React renderer for Threejs
Optimally displays the text as a sprite.
ThreeJS geometry for stroking GeoJSON objects on a sphere
Force-directed graph as a ThreeJS 3d object
stand-alone library of threejs examples
Intl.LocaleMatcher ponyfill
useful add-ons for react-three-fiber
[`react-three-fiber`](https://github.com/drcmda/react-three-fiber) support. This package is for version 6 of react-three-fiber
This is an example application used in The Pragmatic Studio's Ruby Programming course, as described at http://pragmaticstudio.com
A toolset for manipulating and utilizing long text strings. Useful for analyzing user input or bodys of text. Can break text into compacted series of words, sentences and paragraphs.
Provides acts_as_gov_uk_date to mark Rails model attributes as dates that will be entered as three separate text edit boxes, and a form_builder method gov_uk_date_field to display those fields.
The app provides a command-line interface (CLI) to an Ollama AI model, allowing users to engage in text-based conversations and generate human-like responses. Users can import data from local files or web pages, which are then processed through three different modes: fully importing the content into the conversation context, summarizing the information for concise reference, or storing it in an embedding vector database for later retrieval based on the conversation.
This talk describes three Ruby usages: * Implementing high-level interface by Ruby. * Using Ruby as a glue language. * Embedding Ruby into a C program for flexibility. All of them have pros and cons. They are trade-off. If a case can ignore cons, we will have pros for the case. Most of Rubyists implement their Ruby applications only by Ruby. This talk shows another options to use Ruby as your convenient tool. If you know another options and trade-offs of them, you will implement your Ruby applications more effectively. This talk uses Droonga, a distributed full-text search engine, as a sample application to describe these Ruby usages. Droonga uses these three Ruby usages.
A Rails engine that wraps PDF.js to provide a full-featured PDF viewer with text and area highlighting, powered by Stimulus controllers and Tailwind CSS. Includes a three-panel layout with outline/thumbnails sidebar, highlight management, and an overridable right sidebar for custom integrations.
The inner working of an enigma machine has three rotors. Each rotors has wrapped around it the 26 letters. When a key is pressed it moves the rotor ahead one alphabet. The other rotors kick off after the first has completed a revolution and so for the third.When this is done, text in plain english becomes gibberish. Before you start encrypting you and your recipient must agree upon a key which can be set on the machine. Find out more on my GitHub page
BASIC INSTRUCTIONS This gem funds and defunds your projects at random via die roll. The final list of projects is then exported to your current directory after the program has finished ('quit' to exit). TO RUN DEFAULT CSV SHEET (Three example projects))): crowdfund TO RUN A CSV FILE FROM YOUR CURRENT DIRECTORY: crowdfund your_file_name.csv NOTE: All CSV files must be formatted appropriately with: No header or other text at the top! Column 1: lists all project titles in plain text. Column 2: lists integer values for initial project funding amounts (A blank field by default initializes a project with $0 in funding.) Column 3: lists integer values for the project's target goal in funding (A blank field by default initializes a project with $10,000 in funding.)
pikuri-vectordb gives a pikuri-core agent a +vectordb_search+ tool over a local document corpus — agentic search, the agent decides when to retrieve. Ships a swappable backend (a pure-Ruby +Backend::InMemory+ for teaching and a thin +Backend::Chroma+ HTTP client for persistence), a chunker, an embedder wrapper over +RubyLLM.embed+, and an optional +Reranker::LlamaServer+ that speaks +/v1/rerank+ against a cross-encoder model. Text extraction goes through +Pikuri::FileType.read_as_text+ in pikuri-core, which handles plain text / Markdown / PDF; HTML extraction is a deferred follow-up. Hosts wire the feature via +c.add_extension Pikuri::VectorDb::Extension.new(...)+ inside the +Agent.new+ block — same opt-in shape as +pikuri-tasks+ / +pikuri-skills+. The bundled +Pikuri::VectorDb::LIBRARIAN+ persona is the privilege-separated sub-agent counterpart for hosts that want recall to flow through a child rather than the parent's context. Three model endpoints in the full setup — chat (via ruby_llm), an embedder (via +RubyLLM.embed+), and an optional reranker (HTTP +/v1/rerank+). A single +llama-server+ in router mode serves all three by default, loading each cached GGUF on demand; see the gem's README for details.
Welcome to the "Knuckleheads" game, a (slightly enhanced version of the) fully functional text driven game written in Ruby 1.9 and used as a teaching aid for the excellent web-based Ruby course administered by Pragmatic Studios. W00t! W00t! Before playing, fill the default csv file "players.csv" with any number of players by putting the name of each followed by their initial health (an integer separated from the name by a comma). Each player must be on a new line. You may also create an alternate file formatted the same way with a different name. (A sample alternate player file called "more_nuts.csv" is provided as an example.) Invoke an alternate file simply by entering the file name when prompted. How fun is that!! To start the game, start the Ruby file "studio_game.rb" in Ruby 1.9 (or later should work as well) and follow the directions. By the way, there are two players added in hard code with modified behavior. One is "sandro" a LOSER or "clumsy" player who damages his treasure upon collecting it, resulting in the value of each treasure being worth only half of it's original value. What a klutz! The other is a wild-ass player, "bright_eyes." He's a serious partyier! After every other player is spent, he "finds the last beer in the fridge" and can't help but w00t. Bright_eyes starts off just like everyone else. But after being w00ted six times he goes freak'n w00t-crazy and w00ts EVERY TIME! You better think long and hard before committing to joining Mr. bright_eyes. Legend has it that he eats the livers of his prey after he parties them to death, and in this way remains an immortal player! Now fire up that command line for some outrageous fun! CAUTION: It is addictive. My cousin, Schneebo (the Schneebo on my Dad's side, NOT Schneebo Salifronski) once sat down and played Knuckleheads non-stop for 176.39 hours. It's the truth - you've been warned. Oh, and by the way: Three w00ts for Pragmatic Studios - woot, woot, h00ray! - woot, woot, h00ray! - woot, woot, h00ray!
Contentful API wrapper library exposing an ActiveRecord-like interface
== README.md: #ScheduledResource This gem is for displaying how things are used over time -- a schedule for a set of "resources". You can configure the elements of the schedule and there are utilities and protocols to connect them: - Configuration (specification and management), - Query interfaces (a REST-like API and internal protocols to query the models), and - A basic Rails controller implementation. We have a way to configure the schedule, internal methods to generate the data, and a way to retrieve data from the client. However this gem is largely view-framework agnostic. We could use a variety of client-side packages or even more traditional Rails view templates to generate HTML. In any case, to get a good feel in a display like this we need some client-side code. The gem includes client-side modules to: - Manage <b>time and display geometries</b> with "infinite" scroll along the time axis. - <b>Format display cells</b> in ways specific to the resource models. - <b>Update text justification</b> as the display is scrolled horizontally. ## Configuration A **scheduled resource** is something that can be used for one thing at a time. So if "Rocky & Bullwinkle" is on channel 3 from 10am to 11am on Saturday, then 'channel 3' is the <u>resource</u> and that showing of the episode is a <u>resource-use</u> block. Resources and use-blocks are typically Rails models. Each resource and its use-blocks get one row in the display. That row has a label to the left with some timespan visible on the rest of the row. Something else you would expect see in a schedule would be headers and labels -- perhaps one row with the date and another row with the hour. Headers and labels also fit the model of resources and use-blocks. Basic timezone-aware classes (ZTime*) for those are included in this gem. ### Config File The schedule configuration comes from <tt>config/resource_schedule.yml</tt> which has three top-level sections: - ResourceKinds: A hash where the key is a Resource and the value is a UseBlock. (Both are class names), - Resources: A list where each item is a Resource Class followed by one or more resource ids, and - visibleTime: The visible timespan of the schedule in seconds. The example file <tt>config/resource_schedule.yml</tt> (installed when you run <tt>schedulize</tt>) should be enough to display a two-row schedule with just the date above and the hour below. Of course you can monkey-patch or subclass these classes for your own needs. ### The schedule API The 'schedule' endpoint uses parameters <tt>t1</tt> and <tt>t2</tt> to specify a time interval for the request. A third parameter <tt>inc</tt> allows an initial time window to be expanded without repeating blocks that span those boundaries. The time parameters _plus the configured resources_ define the data to be returned. ### More About Configuration Management The <b>ScheduledResource</b> class manages resource and use-block class names, id's and labels for a schedule according to the configuration file. A ScheduledResource instance ties together: 1. A resource class (eg TvStation), 2. An id (a channel number in this example), and 3. Strings and other assets that will go into the DOM. The id is used to - select a resource _instance_ and - select instances of the _resource use block_ class (eg Program instances). The id _could_ be a database id but more often is something a little more suited to human use in the configuration. In any case it is used by model class method <tt>(resource_use_block_class).get_all_blocks()</tt> to select the right use-blocks for the resource. A resource class name and id are are joined with a '_' to form a tag that also serves as an id for the DOM. Once the configuration yaml is loaded that data is maintained in the session structure. Of course having a single configuration file limits the application's usefulness. A more general approach would be to have a user model with login and configuration would be associated with the user. ## Installation Add this line to your application's Gemfile: ```ruby gem 'scheduled_resource' ``` And then execute: $ bundle Or install it yourself as: $ gem install scheduled_resource Then from your application's root execute: $ schedulize . This will install a few image placeholders, client-side modules and a stylesheet under <tt>vendor/assets</tt>, an example configuration in <tt>config/resource_schedule.yml</tt> and an example controller in <tt>app/controllers/schedule_controller.rb</tt>. Also, if you use $ bundle show scheduled_resource to locate the installed source you can browse example classes <tt>lib/z_time_*.rb</tt> and the controller helper methods in <tt>lib/scheduled_resource/helper.rb</tt> ## Testing This gem also provides for a basic test application using angularjs to display a minimal but functional schedule showing just the day and hour headers in two different timezones (US Pacific and Eastern). Proceed as follows, starting with a fresh Rails app: $ rails new test_sr As above, add the gem to the Gemfile, then $ cd test_sr $ bundle $ schedulize . Add lines such as these to <tt>config/routes.rb</tt> get "/schedule/index" => "schedule#index" get "/schedule" => "schedule#schedule" Copy / merge these files from the gem source into the test app: $SR_SRC/app/views/layouts/application.html.erb $SR_SRC/app/views/schedule/index.html.erb $SR_SRC/app/assets/javascripts/{angular.js,script.js,controllers.js} and add <tt>//= require angular</tt> to application.js just below the entries for <tt>jquery</tt>. After you run the server and browse to http://0.0.0.0:3000/schedule/index you should see the four time-header rows specified by the sample config file. ## More Examples A better place to see the use of this gem is at [tv4](https://github.com/emeyekayee/tv4). Specifically, models <tt>app/models/event.rb</tt> and <tt>app/models/station.rb</tt> give better examples of implementing the ScheduledResource protocol and adapting to a db schema organized along somewhat different lines. ## Contributing 1. Fork it ( https://github.com/emeyekayee/scheduled_resource/fork ) 2. Create your feature branch (`git checkout -b my-new-feature`) 3. Commit your changes (`git commit -am 'Add some feature'`) 4. Push to the branch (`git push origin my-new-feature`) 5. Create a new Pull Request
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.