Canvas 1

├── .gitignore ├── AUTHORS ├── CONTRIBUTORS ├── LICENSE ├── README.md ├── content ├── dom │ └── quad_element.go ├── event_listeners.go ├── frame.go └── frame_test.go ├── docs ├── README.md ├── basic-diagram.graffle ├── basic-diagram.svg ├── basictypes.md ├── images.md ├── inkings.md └── introduction.md ├── experiments ├── cocoaview │ ├── app.go │ ├── events.go │ ├── goview.h │ ├── goview.m │ ├── start.h │ └── start.m └── main.go ├── graphics ├── arc.go ├── arc_test.go ├── dual.go ├── float32.go ├── gl.go ├── pointf.go └── rectanglef.go ├── main.go └── window ├── window.go └── window_test.go /.gitignore: -------------------------------------------------------------------------------- 1 | gojiraw 2 | experiments/experiments 3 | -------------------------------------------------------------------------------- /AUTHORS: -------------------------------------------------------------------------------- 1 | # This is the official list of Gojiraw authors for copyright purposes. 2 | # This file is distinct from the CONTRIBUTORS files. 3 | # See the latter for an explanation. 4 | 5 | # Names should be added to this file as: 6 | # Name or Organization 7 | # The email address is not required for organizations. 8 | 9 | # Please keep the list sorted. 10 | 11 | Google Inc. 12 | -------------------------------------------------------------------------------- /CONTRIBUTORS: -------------------------------------------------------------------------------- 1 | # People who have agreed to one of the CLAs and can contribute patches. 2 | # The AUTHORS file lists the copyright holders; this file 3 | # lists people. For example, Google employees are listed here 4 | # but not in AUTHORS, because Google holds the copyright. 5 | # 6 | # https://developers.google.com/open-source/cla/individual 7 | # https://developers.google.com/open-source/cla/corporate 8 | # 9 | # Names should be added to this file as: 10 | # Name 11 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | 2 | Apache License 3 | Version 2.0, January 2004 4 | http://www.apache.org/licenses/ 5 | 6 | TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 7 | 8 | 1. Definitions. 9 | 10 | "License" shall mean the terms and conditions for use, reproduction, 11 | and distribution as defined by Sections 1 through 9 of this document. 12 | 13 | "Licensor" shall mean the copyright owner or entity authorized by 14 | the copyright owner that is granting the License. 15 | 16 | "Legal Entity" shall mean the union of the acting entity and all 17 | other entities that control, are controlled by, or are under common 18 | control with that entity. For the purposes of this definition, 19 | "control" means (i) the power, direct or indirect, to cause the 20 | direction or management of such entity, whether by contract or 21 | otherwise, or (ii) ownership of fifty percent (50%) or more of the 22 | outstanding shares, or (iii) beneficial ownership of such entity. 23 | 24 | "You" (or "Your") shall mean an individual or Legal Entity 25 | exercising permissions granted by this License. 26 | 27 | "Source" form shall mean the preferred form for making modifications, 28 | including but not limited to software source code, documentation 29 | source, and configuration files. 30 | 31 | "Object" form shall mean any form resulting from mechanical 32 | transformation or translation of a Source form, including but 33 | not limited to compiled object code, generated documentation, 34 | and conversions to other media types. 35 | 36 | "Work" shall mean the work of authorship, whether in Source or 37 | Object form, made available under the License, as indicated by a 38 | copyright notice that is included in or attached to the work 39 | (an example is provided in the Appendix below). 40 | 41 | "Derivative Works" shall mean any work, whether in Source or Object 42 | form, that is based on (or derived from) the Work and for which the 43 | editorial revisions, annotations, elaborations, or other modifications 44 | represent, as a whole, an original work of authorship. For the purposes 45 | of this License, Derivative Works shall not include works that remain 46 | separable from, or merely link (or bind by name) to the interfaces of, 47 | the Work and Derivative Works thereof. 48 | 49 | "Contribution" shall mean any work of authorship, including 50 | the original version of the Work and any modifications or additions 51 | to that Work or Derivative Works thereof, that is intentionally 52 | submitted to Licensor for inclusion in the Work by the copyright owner 53 | or by an individual or Legal Entity authorized to submit on behalf of 54 | the copyright owner. For the purposes of this definition, "submitted" 55 | means any form of electronic, verbal, or written communication sent 56 | to the Licensor or its representatives, including but not limited to 57 | communication on electronic mailing lists, source code control systems, 58 | and issue tracking systems that are managed by, or on behalf of, the 59 | Licensor for the purpose of discussing and improving the Work, but 60 | excluding communication that is conspicuously marked or otherwise 61 | designated in writing by the copyright owner as "Not a Contribution." 62 | 63 | "Contributor" shall mean Licensor and any individual or Legal Entity 64 | on behalf of whom a Contribution has been received by Licensor and 65 | subsequently incorporated within the Work. 66 | 67 | 2. Grant of Copyright License. Subject to the terms and conditions of 68 | this License, each Contributor hereby grants to You a perpetual, 69 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable 70 | copyright license to reproduce, prepare Derivative Works of, 71 | publicly display, publicly perform, sublicense, and distribute the 72 | Work and such Derivative Works in Source or Object form. 73 | 74 | 3. Grant of Patent License. Subject to the terms and conditions of 75 | this License, each Contributor hereby grants to You a perpetual, 76 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable 77 | (except as stated in this section) patent license to make, have made, 78 | use, offer to sell, sell, import, and otherwise transfer the Work, 79 | where such license applies only to those patent claims licensable 80 | by such Contributor that are necessarily infringed by their 81 | Contribution(s) alone or by combination of their Contribution(s) 82 | with the Work to which such Contribution(s) was submitted. If You 83 | institute patent litigation against any entity (including a 84 | cross-claim or counterclaim in a lawsuit) alleging that the Work 85 | or a Contribution incorporated within the Work constitutes direct 86 | or contributory patent infringement, then any patent licenses 87 | granted to You under this License for that Work shall terminate 88 | as of the date such litigation is filed. 89 | 90 | 4. Redistribution. You may reproduce and distribute copies of the 91 | Work or Derivative Works thereof in any medium, with or without 92 | modifications, and in Source or Object form, provided that You 93 | meet the following conditions: 94 | 95 | (a) You must give any other recipients of the Work or 96 | Derivative Works a copy of this License; and 97 | 98 | (b) You must cause any modified files to carry prominent notices 99 | stating that You changed the files; and 100 | 101 | (c) You must retain, in the Source form of any Derivative Works 102 | that You distribute, all copyright, patent, trademark, and 103 | attribution notices from the Source form of the Work, 104 | excluding those notices that do not pertain to any part of 105 | the Derivative Works; and 106 | 107 | (d) If the Work includes a "NOTICE" text file as part of its 108 | distribution, then any Derivative Works that You distribute must 109 | include a readable copy of the attribution notices contained 110 | within such NOTICE file, excluding those notices that do not 111 | pertain to any part of the Derivative Works, in at least one 112 | of the following places: within a NOTICE text file distributed 113 | as part of the Derivative Works; within the Source form or 114 | documentation, if provided along with the Derivative Works; or, 115 | within a display generated by the Derivative Works, if and 116 | wherever such third-party notices normally appear. The contents 117 | of the NOTICE file are for informational purposes only and 118 | do not modify the License. You may add Your own attribution 119 | notices within Derivative Works that You distribute, alongside 120 | or as an addendum to the NOTICE text from the Work, provided 121 | that such additional attribution notices cannot be construed 122 | as modifying the License. 123 | 124 | You may add Your own copyright statement to Your modifications and 125 | may provide additional or different license terms and conditions 126 | for use, reproduction, or distribution of Your modifications, or 127 | for any such Derivative Works as a whole, provided Your use, 128 | reproduction, and distribution of the Work otherwise complies with 129 | the conditions stated in this License. 130 | 131 | 5. Submission of Contributions. Unless You explicitly state otherwise, 132 | any Contribution intentionally submitted for inclusion in the Work 133 | by You to the Licensor shall be under the terms and conditions of 134 | this License, without any additional terms or conditions. 135 | Notwithstanding the above, nothing herein shall supersede or modify 136 | the terms of any separate license agreement you may have executed 137 | with Licensor regarding such Contributions. 138 | 139 | 6. Trademarks. This License does not grant permission to use the trade 140 | names, trademarks, service marks, or product names of the Licensor, 141 | except as required for reasonable and customary use in describing the 142 | origin of the Work and reproducing the content of the NOTICE file. 143 | 144 | 7. Disclaimer of Warranty. Unless required by applicable law or 145 | agreed to in writing, Licensor provides the Work (and each 146 | Contributor provides its Contributions) on an "AS IS" BASIS, 147 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 148 | implied, including, without limitation, any warranties or conditions 149 | of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A 150 | PARTICULAR PURPOSE. You are solely responsible for determining the 151 | appropriateness of using or redistributing the Work and assume any 152 | risks associated with Your exercise of permissions under this License. 153 | 154 | 8. Limitation of Liability. In no event and under no legal theory, 155 | whether in tort (including negligence), contract, or otherwise, 156 | unless required by applicable law (such as deliberate and grossly 157 | negligent acts) or agreed to in writing, shall any Contributor be 158 | liable to You for damages, including any direct, indirect, special, 159 | incidental, or consequential damages of any character arising as a 160 | result of this License or out of the use or inability to use the 161 | Work (including but not limited to damages for loss of goodwill, 162 | work stoppage, computer failure or malfunction, or any and all 163 | other commercial damages or losses), even if such Contributor 164 | has been advised of the possibility of such damages. 165 | 166 | 9. Accepting Warranty or Additional Liability. While redistributing 167 | the Work or Derivative Works thereof, You may choose to offer, 168 | and charge a fee for, acceptance of support, warranty, indemnity, 169 | or other liability obligations and/or rights consistent with this 170 | License. However, in accepting such obligations, You may act only 171 | on Your own behalf and on Your sole responsibility, not on behalf 172 | of any other Contributor, and only if You agree to indemnify, 173 | defend, and hold each Contributor harmless for any liability 174 | incurred by, or claims asserted against, such Contributor by reason 175 | of your accepting any such warranty or additional liability. 176 | 177 | END OF TERMS AND CONDITIONS 178 | 179 | APPENDIX: How to apply the Apache License to your work. 180 | 181 | To apply the Apache License to your work, attach the following 182 | boilerplate notice, with the fields enclosed by brackets "[]" 183 | replaced with your own identifying information. (Don't include 184 | the brackets!) The text should be enclosed in the appropriate 185 | comment syntax for the file format. We also recommend that a 186 | file or class name and description of purpose be included on the 187 | same "printed page" as the copyright notice for easier 188 | identification within third-party archives. 189 | 190 | Copyright [yyyy] [name of copyright owner] 191 | 192 | Licensed under the Apache License, Version 2.0 (the "License"); 193 | you may not use this file except in compliance with the License. 194 | You may obtain a copy of the License at 195 | 196 | http://www.apache.org/licenses/LICENSE-2.0 197 | 198 | Unless required by applicable law or agreed to in writing, software 199 | distributed under the License is distributed on an "AS IS" BASIS, 200 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 201 | See the License for the specific language governing permissions and 202 | limitations under the License. 203 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | This project is [Gojiraw](http://google.github.io/gojiraw/) -- a convenient abbreviation of "GO JIffy-fast 2 | RAW-draw". Gojiraw is a library and demo program for a deferred (i.e. 3 | display-list based) GPU-accelerated 2D rendering system. The drawing 4 | primitives (a work in progress) are inspired by the [Plan9 raster 5 | drawing library](https://swtch.com/plan9port/man/man3/draw.html) and the [Blink](http://www.chromium.org/blink) drawing interface. 6 | 7 | -------------------------------------------------------------------------------- /content/dom/quad_element.go: -------------------------------------------------------------------------------- 1 | // Copyright 2014 The Gojiraw Authors. All Rights Reserved. 2 | // 3 | // Licensed under the Apache License, Version 2.0 (the "License"); 4 | // you may not use this file except in compliance with the License. 5 | // You may obtain a copy of the License at 6 | // 7 | // http://www.apache.org/licenses/LICENSE-2.0 8 | // 9 | // Unless required by applicable law or agreed to in writing, software 10 | // distributed under the License is distributed on an "AS IS" BASIS, 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | // See the License for the specific language governing permissions and 13 | // limitations under the License. 14 | 15 | package dom 16 | 17 | import ( 18 | "image/color" 19 | "log" 20 | 21 | "github.com/google/gojiraw/graphics" 22 | ) 23 | 24 | const ( 25 | VERTEX_NON = iota // Draw the default vertex handle. 26 | VERTEX_HOVER // Draw the hover vertex handle. 27 | VERTEX_PRESS // Draw the mouse down vertex handle 28 | NUM_VERTEX_STATES 29 | ) 30 | 31 | const ( 32 | QUAD_ELEMENT_DX = 45. 33 | QUAD_ELEMENT_DY = 45. 34 | QUAD_ELEMENT_DH = 4. 35 | ) 36 | 37 | var modeToColor [NUM_VERTEX_STATES]color.RGBA 38 | 39 | func init() { 40 | modeToColor[VERTEX_NON] = color.RGBA{0, 0, 0, 0xf0} 41 | modeToColor[VERTEX_HOVER] = color.RGBA{0xff, 0, 0, 0xff} 42 | modeToColor[VERTEX_PRESS] = color.RGBA{0, 0, 0xff, 0xff} 43 | } 44 | 45 | func (qe *QuadElement) vertexColor(mode int) color.RGBA { 46 | return modeToColor[mode] 47 | } 48 | 49 | // Element is a placeholder for an element. Will want, not a tree, but a true 50 | // database format for efficent queries (including spatial). 51 | type QuadElement struct { 52 | vertices [4]graphics.Pointf 53 | color color.RGBA 54 | hoverMode int 55 | activeVertex int 56 | } 57 | 58 | func (qe *QuadElement) Init(pt graphics.Pointf) { 59 | qe.vertices[0] = graphics.Pointf{pt.X - QUAD_ELEMENT_DX, pt.Y - QUAD_ELEMENT_DY} 60 | qe.vertices[1] = graphics.Pointf{pt.X + QUAD_ELEMENT_DX, pt.Y - QUAD_ELEMENT_DY} 61 | qe.vertices[2] = graphics.Pointf{pt.X + QUAD_ELEMENT_DX, pt.Y + QUAD_ELEMENT_DY} 62 | qe.vertices[3] = graphics.Pointf{pt.X - QUAD_ELEMENT_DX, pt.Y + QUAD_ELEMENT_DY} 63 | qe.color = color.RGBA{uint8(0), uint8(0), uint8(0), uint8(25)} 64 | qe.hoverMode = VERTEX_NON 65 | qe.activeVertex = -1 66 | } 67 | 68 | func (qe *QuadElement) ActivateVertex(i int) graphics.Pointf { 69 | qe.hoverMode = VERTEX_PRESS 70 | qe.activeVertex = i 71 | return qe.vertices[i] 72 | } 73 | 74 | func (qe *QuadElement) Deactivate() { 75 | qe.hoverMode = VERTEX_HOVER 76 | } 77 | 78 | func (qe *QuadElement) SetActiveVertex(v graphics.Pointf) { 79 | qe.vertices[qe.activeVertex] = v 80 | } 81 | 82 | func (qe *QuadElement) drawHandle(dl *graphics.DisplayList) { 83 | dl.SetPointSize(2.) 84 | dl.SetColor(qe.vertexColor(VERTEX_NON)) 85 | 86 | var ps [4]graphics.Pointf 87 | count := 0 88 | for i, p := range qe.vertices { 89 | if qe.hoverMode == VERTEX_NON || i != qe.activeVertex { 90 | ps[count] = p 91 | count++ 92 | } 93 | } 94 | 95 | dl.DrawPoints(ps[:]) 96 | if qe.hoverMode != VERTEX_NON { 97 | log.Printf("drawing hover vertex") 98 | dl.SetPointSize(2 * QUAD_ELEMENT_DH) 99 | if qe.hoverMode == VERTEX_HOVER { 100 | dl.SetColor(qe.vertexColor(VERTEX_HOVER)) 101 | } else { 102 | dl.SetColor(qe.vertexColor(VERTEX_PRESS)) 103 | } 104 | dl.DrawPoints([]graphics.Pointf{qe.vertices[qe.activeVertex]}) 105 | } 106 | } 107 | 108 | // TODO(vollick): split this out into an interface. 109 | func (qe *QuadElement) Draw(dl *graphics.DisplayList) { 110 | dl.SetColor(qe.color) 111 | dl.DrawQuads([][4]graphics.Pointf{qe.vertices}) 112 | qe.drawHandle(dl) 113 | } 114 | 115 | func (qe *QuadElement) FindVertex(p graphics.Pointf) int { 116 | o := graphics.Pointf{QUAD_ELEMENT_DH, QUAD_ELEMENT_DH} 117 | for i, v := range qe.vertices { 118 | r := graphics.Rectanglef{v.Sub(o), v.Add(o)} 119 | if p.In(r) { 120 | return i 121 | } 122 | } 123 | return -1 124 | } 125 | 126 | func (qe *QuadElement) HoverOn(v int) { 127 | log.Printf("HoverOn %d", v) 128 | qe.hoverMode = VERTEX_HOVER 129 | qe.activeVertex = v 130 | } 131 | 132 | func (qe *QuadElement) HoverOff() { 133 | log.Printf("HoverOff") 134 | qe.hoverMode = VERTEX_NON 135 | } 136 | -------------------------------------------------------------------------------- /content/event_listeners.go: -------------------------------------------------------------------------------- 1 | // Copyright 2014 The Gojiraw Authors. All Rights Reserved. 2 | // 3 | // Licensed under the Apache License, Version 2.0 (the "License"); 4 | // you may not use this file except in compliance with the License. 5 | // You may obtain a copy of the License at 6 | // 7 | // http://www.apache.org/licenses/LICENSE-2.0 8 | // 9 | // Unless required by applicable law or agreed to in writing, software 10 | // distributed under the License is distributed on an "AS IS" BASIS, 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | // See the License for the specific language governing permissions and 13 | // limitations under the License. 14 | 15 | package content 16 | 17 | import ( 18 | "image" 19 | "log" 20 | ) 21 | 22 | // | These together to record which button is up or down. 23 | // In particular: the buttons value will be some or of the following. 24 | const ( 25 | MOUSE_BUTTON_NONE = 0 26 | ) 27 | 28 | // Reset iota. 29 | const ( 30 | MOUSE_BUTTON_LEFT = 1 << iota 31 | MOUSE_BUTTON_MIDDLE 32 | MOUSE_BUTTON_RIGHT 33 | ) 34 | 35 | const ( 36 | EVD_NON = iota // There is no handler. 37 | EVD_PREVDEF // A handler exists and it wishes the default action for the event to be suppressed. 38 | EVD_DEF // A handler exists and it wants the default action. 39 | ) 40 | 41 | // Anything Frame-like entity capable of receiving events 42 | // needs to implement this interface. 43 | type EventHandler interface { 44 | // Corresponds to JS registered with onmousedown 45 | Mousedown(pt image.Point, button, buttons uint32) uint32 46 | 47 | // Corresponds to JS registered with onmouseup 48 | Mouseup(pt image.Point, button, buttons uint32) uint32 49 | 50 | // Corresponds to JS registered with onmousemove 51 | Mousemove(pt image.Point, buttons uint32) uint32 52 | 53 | // Corresponds to JS registered with onmousewheel 54 | Wheel(pt image.Point, buttons uint32, dx, dy, dz float32) uint32 55 | } 56 | 57 | // These are "event listeners": functionality that really 58 | // ought to belong in the JavaScript code of the browser. 59 | // As of yet, this code is busily running here though written in 60 | // Go. Writing these handlers will help define the interfaces that 61 | // we need to schlep events from browser to the v8 thread. 62 | // 63 | // General scheme: in a future with JavaScript, the content side (i.e. main thread) 64 | // for these handlers would receive the event bundle and call into v8 65 | // On the browser side, the messaging proxy would handle this. 66 | // 67 | func (f *Frame) Mousedown(pt image.Point, button, buttons uint32) uint32 { 68 | log.Printf("OnMouseDown") 69 | 70 | e, v := f.FindElementAtPoint(pt) 71 | if e != nil && v > -1 { 72 | f.StartMouseDownMode(pt, e, v) 73 | } 74 | return EVD_PREVDEF 75 | } 76 | 77 | func (f *Frame) Mouseup(pt image.Point, button, buttons uint32) uint32 { 78 | if button == 0 && f.mouseDown { 79 | f.EndMouseDownMode() 80 | } else if button == 0 { 81 | f.AddElement(pt) 82 | } 83 | return EVD_PREVDEF 84 | } 85 | 86 | func (f *Frame) Mousemove(pt image.Point, buttons uint32) uint32 { 87 | if buttons&MOUSE_BUTTON_LEFT == MOUSE_BUTTON_LEFT { 88 | f.InMouseDownMode(pt) 89 | } else { 90 | e, v := f.FindElementAtPoint(pt) 91 | f.MouseOver(e, v) 92 | } 93 | return EVD_PREVDEF 94 | } 95 | 96 | func (f *Frame) Wheel(pt image.Point, buttons uint32, dx, dy, dz float32) uint32 { 97 | // The container for the frame scrolls. 98 | return EVD_NON 99 | } 100 | -------------------------------------------------------------------------------- /content/frame.go: -------------------------------------------------------------------------------- 1 | // Copyright 2014 The Gojiraw Authors. All Rights Reserved. 2 | // 3 | // Licensed under the Apache License, Version 2.0 (the "License"); 4 | // you may not use this file except in compliance with the License. 5 | // You may obtain a copy of the License at 6 | // 7 | // http://www.apache.org/licenses/LICENSE-2.0 8 | // 9 | // Unless required by applicable law or agreed to in writing, software 10 | // distributed under the License is distributed on an "AS IS" BASIS, 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | // See the License for the specific language governing permissions and 13 | // limitations under the License. 14 | 15 | package content 16 | 17 | import ( 18 | "image" 19 | "log" 20 | 21 | "github.com/google/gojiraw/content/dom" 22 | "github.com/google/gojiraw/graphics" 23 | "github.com/go-gl/gl" 24 | ) 25 | 26 | // Frame is the Gojira equivalent of a RenderFrame in Chrome? 27 | // The basic skeleton of shipping the display list and RenderFrame 28 | // sizes between processes will probably entail re-writing this. 29 | // Note(vollick): Frames always have documents. Documents are currently 30 | // "special" in blink in that they don't have a renderer. Let's just leave the 31 | // document related code in Frame. If anything, "document" could just be an 32 | // interface Frame implements. 33 | type Frame struct { 34 | // Probably gonna own a page. :) 35 | // (Note(vollick): Pages are the things that own frame trees. I think 36 | // that's analogous to windows. Let's move the page code into window.) 37 | 38 | // Translation 39 | // TODO(vollick): Probably want a transform here to capture scaling. 40 | x, y, z float32 41 | 42 | // Viewport 43 | w, h float32 44 | 45 | // The most recently mouse-overed element or nil. 46 | overElement *dom.QuadElement 47 | 48 | // The mouse is down. 49 | mouseDown bool 50 | 51 | // A floating point offset from a mouseDown to the centroid of the handle. 52 | // TODO(vollick): It's fishy that Frame knows anything about "handles." 53 | offset graphics.Pointf 54 | 55 | // The root of the document. 56 | document []dom.QuadElement 57 | } 58 | 59 | // AddElement extends the document slice and fills in the new element with a 60 | // quad. 61 | func (f *Frame) AddElement(p image.Point) { 62 | ne := len(f.document) 63 | nd := f.document[0 : ne+1] 64 | pf := graphics.Ptfi(p) 65 | // Note: the following code initializes the new point into the allocated 66 | // memory in the document list. It does *not* resize the list; if we have 67 | // more than 1000 quads, we'll die. 68 | // TODO(vollick): make this dynamic. 69 | (&nd[ne]).Init(pf) 70 | f.document = nd 71 | } 72 | 73 | // Find the control point, if any, under Point p. Return nil, 0 if there is no 74 | // control point for an element under p. The returned int is the index 75 | // of the vertex. 76 | // TODO(rjkroege): The model could be a tree eventually. :-) 77 | func (f *Frame) FindElementAtPoint(p image.Point) (*dom.QuadElement, int) { 78 | pf := graphics.Ptfi(p) 79 | log.Printf("FindElementAtPoint %v", p) 80 | for i := len(f.document) - 1; i >= 0; i-- { 81 | if v := f.document[i].FindVertex(pf); v != -1 { 82 | return &f.document[i], v 83 | } 84 | } 85 | return nil, -1 86 | } 87 | 88 | // Adjusts visual style for elements that are under the 89 | // mouse pointer. 90 | func (f *Frame) MouseOver(qe *dom.QuadElement, v int) { 91 | log.Printf("MouseOver: %+v, %d", qe, v) 92 | if f.overElement != nil && f.overElement != qe { 93 | f.overElement.HoverOff() 94 | } 95 | f.overElement = qe 96 | if qe != nil { 97 | qe.HoverOn(v) 98 | } 99 | } 100 | 101 | // Pan sets a translation on the Frame to permit the Frame to move around within 102 | // its viewport. Translates the viewport w.r.t. the Frame origin by p. 103 | func (f *Frame) Pan(dx, dy float32) { 104 | f.x = graphics.MinF(f.x+dx, f.w) 105 | f.y += graphics.MinF(f.y+dy, f.h) 106 | log.Printf("translation: %d %d", f.x, f.y) 107 | } 108 | 109 | // Resize tells the frame what its size should be. 110 | func (f *Frame) Resize(w, h float32) { 111 | f.w = graphics.MaxF(w, f.w) 112 | f.h = graphics.MaxF(h, f.h) 113 | log.Printf("current size: %d %d", f.w, f.h) 114 | } 115 | 116 | func NewFrame() *Frame { 117 | // TODO(vollick): allow more than 1000 things. 118 | d := make([]dom.QuadElement, 0, 1000) 119 | return &Frame{document: d} 120 | } 121 | 122 | // TODO(rjk): Tell the Frame to clip its drawing to a given viewport. 123 | // x, y is the position of the Frame's origin in the containing port. 124 | // w, h is the width and height of the port in the port's coordinates. 125 | // Returns the enclosing boundary of the Frame. 126 | // TODO(rjkroege): boundaries should admit objects outside [0, w), [0. h)? 127 | // TODO(rjkroege): Provide and wire in types for stuff, boxes, etc. 128 | func (frame *Frame) Draw(x, y, vw, vh float32, program *gl.Program) (fw, fh float32) { 129 | // Build the display list. 130 | dl := &graphics.DisplayList{} 131 | for _, e := range frame.document { 132 | e.Draw(dl) 133 | } 134 | 135 | gl.ClearColor(1, 1, 1, 0) 136 | graphics.CheckForGLErrors() 137 | gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT) 138 | graphics.CheckForGLErrors() 139 | 140 | gl.Enable(gl.BLEND) 141 | gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA) 142 | graphics.CheckForGLErrors() 143 | 144 | dl.Draw(program, vw, vh) 145 | 146 | return dl.W, dl.H 147 | } 148 | 149 | func (f *Frame) StartMouseDownMode(pt image.Point, qe *dom.QuadElement, v int) { 150 | f.overElement = qe 151 | f.mouseDown = true 152 | pf := graphics.Ptfi(pt) 153 | f.offset = pf.Sub(qe.ActivateVertex(v)) 154 | } 155 | 156 | func (f *Frame) InMouseDownMode(pt image.Point) { 157 | // Is this idiomatic? 158 | pf := graphics.Ptfi(pt) 159 | if qe := f.overElement; qe != nil { 160 | qe.SetActiveVertex(pf.Add(f.offset)) 161 | } 162 | } 163 | 164 | func (f *Frame) EndMouseDownMode() { 165 | f.mouseDown = false 166 | f.overElement.Deactivate() 167 | } 168 | -------------------------------------------------------------------------------- /content/frame_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2014 The Gojiraw Authors. All Rights Reserved. 2 | // 3 | // Licensed under the Apache License, Version 2.0 (the "License"); 4 | // you may not use this file except in compliance with the License. 5 | // You may obtain a copy of the License at 6 | // 7 | // http://www.apache.org/licenses/LICENSE-2.0 8 | // 9 | // Unless required by applicable law or agreed to in writing, software 10 | // distributed under the License is distributed on an "AS IS" BASIS, 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | // See the License for the specific language governing permissions and 13 | // limitations under the License. 14 | 15 | package content 16 | 17 | import ( 18 | "github.com/google/gojiraw/content/dom" 19 | "github.com/rjkroege/wikitools/testhelpers" 20 | "image" 21 | "testing" 22 | ) 23 | 24 | func Test_FindElementAtPoint(t *testing.T) { 25 | f := NewFrame() 26 | testhelpers.AssertInt(t, 0, len(f.document)) 27 | 28 | p := image.Pt(10, 10) 29 | 30 | e, _ := f.FindElementAtPoint(p) 31 | if e != nil { 32 | t.Errorf("empty display list can't have element in it") 33 | } 34 | 35 | f.AddElement(image.Pt(30, 10)) 36 | f.AddElement(image.Pt(10, 30)) 37 | 38 | e, v := f.FindElementAtPoint(p) 39 | if e != nil { 40 | t.Errorf("despite a point outside the elements, we hit anyway: %+v", e) 41 | } 42 | 43 | e, v = f.FindElementAtPoint(image.Pt(30-dom.QUAD_ELEMENT_DX, 10+dom.QUAD_ELEMENT_DY)) 44 | if e == nil || *e != f.document[0] { 45 | t.Errorf("point 30,10 in %+v but found element is %+v", f.document[0], e) 46 | } 47 | if v != 3 { 48 | t.Errorf("desired vertex 3 but didn't get it %d", v) 49 | } 50 | } 51 | -------------------------------------------------------------------------------- /docs/README.md: -------------------------------------------------------------------------------- 1 | Design notes for Gojiraw go here. 2 | 3 | My intent was that design notes are written in 4 | [Markdown](http://daringfireball.net/projects/markdown/syntax) and use 5 | [CriticMarkup](http://criticmarkup.com/spec.php) for comments. 6 | GitHub doesn't however support CriticMarkup. I'll use 7 | task lists instead. 8 | 9 | Reading order: 10 | 11 | * [Introduction](introduction.md) 12 | * [Basic types](basictypes.md) 13 | * [Images](images.md) 14 | * [Inkings](inkings.md) 15 | -------------------------------------------------------------------------------- /docs/basic-diagram.graffle: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/google/gojiraw/ba5fac2f7b1f77d235f6ac934c9b71d5e22778b5/docs/basic-diagram.graffle -------------------------------------------------------------------------------- /docs/basic-diagram.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | -------------------------------------------------------------------------------- /docs/basictypes.md: -------------------------------------------------------------------------------- 1 | This section describes the primtive types largely to flesh out some 2 | of the other more interesting sections. See the source for the 3 | actual definition. 4 | 5 | # Geometry 6 | Standard geometry definitions. 7 | 8 | ```go 9 | package geometry 10 | 11 | type Point struct { 12 | x float 13 | y float 14 | } 15 | 16 | type Rectangle struct { 17 | min Point 18 | max Point 19 | } 20 | 21 | type Matrix struct { 22 | // numbers... 23 | } 24 | 25 | func (m Matrix) TransformRect(r Rectangle) Rectangle 26 | // Produces a Matrix that translates by p 27 | func Translate(p Point) Matrix 28 | 29 | ``` 30 | 31 | # Drawop 32 | Each of the compositing operations in Porter-Duff compositing. 33 | Names and definitions per Plan9. 34 | 35 | ```go 36 | package drawop 37 | 38 | const ( 39 | Clear = 0 40 | DoutS = 1 << iota 41 | SoutD = 2 42 | DinS = 4 43 | SinD = 8 44 | S = SinD|SoutD 45 | SoverD = SinD|SoutD|DoutS 46 | SatopD = SinD|DoutS 47 | SxorD = SoutD|DoutS 48 | D = DinS|DoutS 49 | DoverS = DinS|DoutS|SoutD 50 | DatopS = DinS|SoutD 51 | DxorS = DoutS|SoutD /* == SxorD */ 52 | Ncomp = 12 53 | ) 54 | ``` 55 | 56 | # Glyph 57 | Gojiraw deliberately excludes font shaping from its scope. Instead, it deals 58 | in *glyphs*. 59 | 60 | 61 | ```go 62 | type Glyph int32 63 | ``` 64 | 65 | NB: a `glyph` is *not* a UTF `rune`. Gojiraw will attempt to create an 66 | equivalence between valid runes and the letter shape associated with 67 | the identical glyph. For example, rune 0x41 is a valid UTF code point 68 | and also a valid glyph to reference the letter shape for `A` in the 69 | current style. This convenience makes sense when font shaping is 70 | unused as it permits treating most rune arrays as an identical glyph 71 | array. The `utf8.ValidRune(rune)` method will determine if a given 72 | glyph corresponds to a actual UTF code point. 73 | 74 | -------------------------------------------------------------------------------- /docs/images.md: -------------------------------------------------------------------------------- 1 | # Image 2 | An `Image` is an `Inkings` augmented with an optional rectangular 3 | expanse of pixels that can be the target of GPU rasterization or the 4 | source for scanout to the `Display` These pixels are not inside the 5 | Image structure. Instead, the system (i.e. GPU) owns the actual 6 | pixels. 7 | 8 | It is possible that we must support referring to the underlying pixel 9 | data in two different processes. If so, we need a mechanism to pass 10 | image data handles between processes using an operating system 11 | appropriate mechanism such as `gralloc` buffers or `IOSurface` 12 | objects. We should however attempt to satisfy the needs of Gojiraw 13 | clients without providing such a facility as (at least in my opinion) 14 | inter-process GPU image transport has brought enormous complexity to 15 | Chrome. 16 | 17 | When overlays are available, a presentable `Image` will own no pixel 18 | data itself. Instead, it will contain (as it is an `Inkings`) one or 19 | more children `Image` objects that each have their own GPU-resident 20 | pixel data that will be used for scanout. 21 | 22 | ```go 23 | const ( 24 | _ = iota 25 | OverlayCandidate = iota 26 | ) 27 | 28 | type Image interface { 29 | Load(r Rectangle, data []byte, opts ...interface{}) <-channel error 30 | Unload(r Rectangle, data []byte, opts ...interface{}) <-channel error 31 | Release() 32 | NewImage(r Rectangle, opts ...interface{}) (Image, error) 33 | } 34 | 35 | func Zero() Image 36 | ``` 37 | 38 | ## LoadImage 39 | `Load` fills `Rectangle r` with pixel `data` as controlled by the 40 | additional configuration options. The routine returns immediately. The 41 | returned channel indicates when the uploading process has completed. 42 | 43 | Options specify stride, packing etc. as suggested by the arguments to 44 | `glTexSubImage2D`. 45 | 46 | - [ ] Am I providing a rich enough API surface for copy minimization 47 | - [ ] I need to refine and make precise how we can determine and take 48 | advantage of hardware support for image conversion (decompression for 49 | example) during the execution of a `Load` operation. 50 | - [ ] The error should be available synchronously. 51 | 52 | ## Unload 53 | `Unloadimage` reads a rectangle of pixels from the target `Image` and writes 54 | it into data as controlled by the options. The returned channel indicates when 55 | the uploading process has completed. 56 | 57 | ## Release 58 | `Release` explicitly relinquishes the storage underlying this `Image`. Rational: GPU 59 | image data is large, GPU memory is frequently special and/or in short supply. 60 | So provide a mechanism to explicitly indicate when the memory backing 61 | an `Image` is no longer needed. 62 | 63 | ## NewImage 64 | `NewImage` creates an `Image` as specified by the provided options. 65 | Options include the `OverlayCandidate` to indicate that this `Image` 66 | should have backing storage allocated in a fashion that it could be a 67 | scanout source. 68 | 69 | The created `Image` object will use the same GPU pixel storage as 70 | the target object. 71 | 72 | Attempting to render an `Image` object to an `Image` that does not share 73 | the same GPU storage will fail. 74 | 75 | - [ ] Specify when this failure is detected and indicated. 76 | 77 | # Display 78 | `Display` contains state about the connected graphics system. 79 | A `Display` is also an `Image`. A `Display` containing multiple screens will 80 | have several different child `Display` objects corresponding to the actual 81 | screens. 82 | 83 | - [ ] This section ignores that screens can refresh at different rates and 84 | that the Display could be generated by multiple different GPUs. Address. 85 | 86 | ```go 87 | type RefreshDeadline struct { 88 | VblankEnd time.Duration 89 | NextVblankEnd time.Duration 90 | } 91 | 92 | type ScreenInfo struct { 93 | // TBD 94 | } 95 | 96 | type Display interface { 97 | Image 98 | RefreshDeadlineChannel() <-channel RefreshDeadline 99 | Screens() []Display 100 | ScreensInfo() []ScreenInfo 101 | } 102 | 103 | NewMockDisplay(opts ...interface{}) Display 104 | NewDisplay(opts ...interface{}) Display 105 | ``` 106 | 107 | ## RefreshDeadlineChannel 108 | `RefreshDeadlineChannel` returns a channel that becomes ready on 109 | the start of a vblank and provides the `time.Duration` into the future 110 | of the end of the vblank interval and the end of the *next vblank*. 111 | 112 | ## Screens 113 | `Screens` return the children `Display` objects, one for each 114 | physically attached screen. Enumerate the size of actual monitors on 115 | the system like this: 116 | 117 | ```go 118 | 119 | display := NewDisplay(/* details elided */) 120 | for i, s := range display.Screens() { 121 | r := s.Bound() 122 | fmt.Printf("[%d] x %f y %f w %f h %f", i, r.min.x, r.min.y, r.max.x - r.min.x, r.max.y - r.min.y) 123 | } 124 | ``` 125 | 126 | ## ScreensInfo 127 | `ScreensInfo` returns an array of additional information for each attached screen. 128 | 129 | ## Discussion 130 | Create an `Image` for by using `NewImage` on a `Display`. In the multiple screens 131 | case, it will be an error to attempt to do so on the top-level `Display` object. 132 | 133 | `NewMockDisplay()` returns a `Display` whose `Image` objects are memory 134 | resident and cannot be used for scanout. For example, the following 135 | code fragment would provide functionality resembling the ozone files 136 | backend. 137 | 138 | ```go 139 | model := NewInkings() 140 | tick := 0 141 | display := NewMockDisplay() 142 | 143 | for { 144 | select { 145 | case e := <-getNextEvent(): 146 | appUpdatesModelForEvent(model, e) 147 | case <-time.Tick(time.Millisecond * 16): 148 | snapshot := <-ink.Clone() 149 | go func(snapshot Inkings, tick int) { 150 | r := geom.Rect{geom.Point{0,0}, geom.Point{1024, 768}} 151 | image, _ := display.NewImage(r) 152 | <-snapshot.Render(image) 153 | buf := make([]byte, 1024 * 768 * 4) 154 | <-image.Unload(buf, r, /* options for packed, contiguous, alpha, etc. */) 155 | ioutil.WriteFile(fmt.Sprintf("frame_%d", tick), buf, 0x644) 156 | } 157 | tick += 1 158 | } 159 | } 160 | ``` 161 | 162 | `Show` on a `Display` object has different semantics than it does on 163 | an arbitrary `Inkings` In particular: it sets the display controller 164 | to scanout from the provided `Image` immediately. Users of the entry 165 | point wishing to avoid tearing should use the 166 | `RefreshDeadlineChannel()` channel to limit these `Show` calls to 167 | inside the vblank interval. 168 | 169 | ```go 170 | display := NewDisplay() // Assume one screen. 171 | model := NewInkings() 172 | 173 | // This would compile but is silly. 174 | display.Render(display) 175 | 176 | // Make a new Image. 177 | image := display.NewImage(Rect{{0,0}, {1024,768}}) 178 | 179 | // Add enzo to image... 180 | 181 | // This is allowed. Only image Enzo corresponding to overlay 182 | // planes remain. 183 | <-image.Render(image) 184 | 185 | // Show on a display means that display hardware is now scanning 186 | // out from image. 187 | <-display.Show(image) 188 | 189 | // This code executes on the vblank after the frame in which image 190 | // was the scanout source. 191 | fmt.Printf("hello") 192 | ``` 193 | 194 | -------------------------------------------------------------------------------- /docs/inkings.md: -------------------------------------------------------------------------------- 1 | # Enso 2 | `Enso` is a single simple drawable entity like a circle. The word is 3 | from Zen Buddhist calligraphy and means (literally) circle. An Enzo 4 | combines geometry and paint into an opaque object that has membership 5 | in an Inkings. 6 | 7 | ``` 8 | type Enso uint32 9 | ``` 10 | 11 | As with a calligraphic strokes, an Enso is immutable once stroked into 12 | an Inkings. Enzo immutability is intended to permit the library to 13 | take any combination of deferred and eager rasterization of the Enzo 14 | recorded into a specific Inkings. 15 | 16 | For example, a ideal Gorjiraw implementation would convert a sequence 17 | of `Enzo` into an array of floating point numbers and a shader 18 | program. Redrawing the `Enzo` would proceed in the best case 19 | GPU-accelerated fashion: call GPU library with pointer to float array 20 | and pre-compiled shader program. 21 | 22 | # Inkings 23 | Inkings are a mutable record of multiple Enzo and other Inkings. 24 | Inkings form a DAG. Inkings can be rasterized to an Image and hence 25 | presented to the Display. 26 | 27 | My intent with Inkings is to provide a plug-compatible substitute for 28 | an Image except that, per the non-blocking principle, the pixel 29 | contents are available only as a promise. 9p Images are frequently the 30 | source and destination for the same draw operation. To preserve 31 | this capability, lazy rasterization and the mutability of the Inkings, 32 | Inkings offer a `Clone` function. 33 | 34 | A naïve algorithm for rasterizing an Inkings is to postfix depth-first 35 | traverse the Inkings graph, allocating an Image for each Inkings and 36 | rasterizing its Enzo before combining Inkings into their parent Image 37 | via texture draw. 38 | 39 | ```go 40 | type Inkings Interface { 41 | Repl() bool 42 | Bound() Rectangle 43 | Clipr() Rectangle 44 | 45 | Clone() <-channel Inkings 46 | Zero() 47 | 48 | Render(i Image, opts ...interface{}) <-channel Image 49 | Show(i Image, opts ...interface{}) <-channel Image 50 | 51 | // r generalizes to a Path. Worry about that later. 52 | DrawInkings(r Rectangle, src, mask *Inkings, m *Matrix, d Drawop) Enzo 53 | ReDrawInkings(eid Enzo, r Rectangle, src, mask *Inkings, m *Matrix, d Drawop) Enzo 54 | 55 | GlyphString(glyphs []Glyph, styles []byte, stylefonts []StyledFont, p Point, m Matrix) Point 56 | } 57 | 58 | func NewInkings() (Inkings, error) { 59 | } 60 | ``` 61 | 62 | ## NewInkings 63 | `NewInkings` creates a new Inkings. Each Inkings is (conceivably) 64 | infinite in extent and has its own coordinate system. A new empty 65 | Inkings is transparent (alpha = 0) and therefore has no effect when 66 | added to another Inkings. 67 | 68 | ## Clone 69 | `Clone` returns a channel that will contain a deep clone of the target 70 | `Inkings`. Modifying `target` while `Clone` is in progress may have 71 | undefined behaviour. Clone is central to how to use the Gojiraw API: 72 | maintain a `Inkings` *model*, `Clone` it and render that. 73 | 74 | ```go 75 | 76 | // Many elided details... 77 | model := NewInkings() 78 | var display := NewDisplay() 79 | 80 | wins := make(channel Image, 2) 81 | wins <- currentDisplay.NewImage( /* ... */) 82 | wins <- currentDisplay.NewImage(/* ... */), 83 | 84 | rc := display.RefreshDeadlineChannel() 85 | var snapshot Inkings 86 | 87 | ni var <-channel Image 88 | 89 | for { 90 | select { 91 | case <-rc: 92 | snapshot := <- ink.Clone() 93 | win := <- wins 94 | // TODO(rjk): The channel needs to be passed 95 | // in so that Image objects can be reused more easily. 96 | ni = shown = <-snapshot.Show(win) 97 | case im := <- ni 98 | win <- im 99 | case e := <-NextEvent 100 | appUpdatesModelForEvent(model, e) 101 | } 102 | } 103 | ``` 104 | 105 | ## Render 106 | `Render` asynchronously rasterizes the target `Inking` to `Image i` and 107 | triggers the returned channel with an updated `Image` object that contains 108 | only rendered `Images`. 109 | 110 | The returned `Image` may not be "flat". The `Inkings` may request use 111 | of overlays by containing children `Image` objects that have the 112 | `OverlayCandidate` attribute set. Then, the children `Image` objects 113 | of the returned `Image` will correspond to hardware planes. 114 | 115 | Between invoking this call and before the channel is triggered, the caller 116 | should not modify the `Image`. 117 | 118 | Some `Inkings` in the DAG may need longer than others. Intermediate 119 | `Image` objects can be multi-buffered to accomodate this. 120 | 121 | - [ ] Figure out if this requires `Clone` to be synchronous. 122 | 123 | ## Show 124 | `Show` combines rendering with presentation. It asynchronously performs the following steps 125 | 126 | * rasterize the target `Inking` to `Image i`. 127 | * on the next vblank after rasterization, scan from `Image i` 128 | * on next vblank after that, trigger the channel with `Image i` 129 | 130 | ## Zero 131 | `Zero` removes all the Enzos from the `Inkings`. 132 | 133 | ## Bound 134 | `Bound` returns the smallest `Rectangle` enclosing the entire 135 | `Inkings` 136 | 137 | ## DrawInkings 138 | The most basic drawing operation in Gojiraw. It records an Enzo 139 | wrapping `src`, `mask`, `m`, `op` in Inkings `target` and returns an 140 | Enzo identifier. 141 | 142 | DrawInkings has the following semantics for rasterization: 143 | 144 | * create Rectangle `r` in the coordinate system of `target`. 145 | 146 | * interesect `r` with `target.Clipr` (and other clips that might exist.) 147 | 148 | * `m` transforms `r` from the target's coordinate system into `src`. 149 | Combining `r` and `m` permit picking out an arbitrary 150 | rectangle from `src`. 151 | 152 | * `m` also transforms `r` from the target's CS into `mask` in identical fashion. 153 | 154 | * if `src.Repl` is set, consider `src` to tile its plane and if `mask.Repl` is set, consider `mask` to tile its plane. 155 | 156 | * for each pixel location in `r`, combine `target` pixel with `src` pixel using alpha 157 | provided by `mask` pixel using Porter-Duff composition specified by `op`. 158 | 159 | Note that `Image` objects are usable as `Inkings` so this method also 160 | offers the capability of drawing `Image` objects. 161 | 162 | ## ReDrawInkings 163 | Operates identically to `DrawInkings` except that rather than adding a new 164 | Enzo to Inkings `target`, replaces the specified Enzo. 165 | 166 | # GlyphString 167 | `GlyphString` efficiently draws runs of styled text. 168 | The server does not line-break the provided run. 169 | 170 | * `glyphs` an array of glyphs. NB: glyphs are not necessarily runes in order to support 171 | languages like Arabic and ligatures. It seems convenient that runes are 1-1 with glyphs 172 | where possible. For example, glyph 0x41 could be `A`. 173 | * `styles` an array of 1 byte style identies, one per glyph or alternatively an array of 174 | length 1 which selects the StyleFont used for every glyph. 175 | * 'styledfonts' is an array of `StyleFont` objects. Each byte in `styles` chooses 176 | the `StyleFont` used to draw the corresponding glyph in `glyphs` 177 | * `p` is a `Point` specifying where to position the origin corner of the glyph in 178 | the coordinate system of the target `Inkings`. 179 | * 'm' is a `Matrix` that specifies the how to advance to the next glyph position: next `p` 180 | is `p += m * glyph-bounds`. 181 | 182 | Because no line breaking is done. `\n` is treated as white space. Per the 183 | Plan9 `string` function, `GlyphString` "returns a `Point` that is the 184 | position of the next character that would be drawn if the string were 185 | longer." 186 | 187 | Drawing proceeds as the following "Go with vector operations" pseudo-code 188 | 189 | ```go 190 | // A conceptually workable but brutally slow definition of outline fonts. 191 | // The outline origin has its natural meaning. 192 | type StyleFont []Inkings 193 | 194 | m1 := geometry.Translate(p) 195 | 196 | for i, _ := range glyphs { 197 | im := styledfonts[styles[i]][glyphs[i]] 198 | DrawInkings(m1.TransformRect(im.Bound()), im, im, m1, drawop.DoverS) 199 | m1 = m1 + m * (im.Bound.Max - im.Bound.Min) 200 | } 201 | 202 | return /* translation in x and y from m1 */ 203 | ``` 204 | 205 | *insert diagram* 206 | 207 | 208 | ## Discussion 209 | We require: 210 | 211 | * efficient encoding of styled text runs 212 | * a way to control the advance so that runs can be drawn right to left or vertically 213 | * efficient font metrics access on both the client and the server. 214 | * mechanism for client to prepare and upload glyph representations. 215 | 216 | Lots of really tiny text runs need to be efficient. In particular, 217 | this means not shipping the text font name, font description, style 218 | name, size, etc. over again. For example, trying to use the existing 219 | `