Crossbridge sample 02 Interop

破晓 · 发表于 2015-1-4 17:27:48

Crossbridge = FlasCC = Alchemy

接續上一篇Crossbridge 編譯後運行 Sample 1 HelloWorld

如果是用 Java 32 的話，先修改D:Crossbridge_1.0.1samples_Interop內的Makefile在4、7、10、13行的後面輸入 -jvmopt=-Xmx1G

運行D:Crossbridge_1.0.1內的run.bat，並輸入cd 02_Interop，再輸入make，會編譯4個檔案，我等了5分鐘，有點久看來我應該換個給力一點的電腦，換了一台 i7 3770 編譯了1分半

分別是編譯這4個檔案
hellointerop.c 編譯成 hellointerop.exe 和 hellointerop.swf
c++interop.cpp 編譯成 c++interop.swf
bitmapdata.cpp 編譯成 bitmapdata.swf

首先讓我們來運行一下 hellointerop.exe，輸入./hellointerop

再來看一下 hellointerop.swf

之後 c++interop.swf

最後 bitmapdata.swf

總覺得 c++interop.swf 和 bitmapdata.swf 檔案竟然如此大，2973k和2934k，這種簡單的畫圈圈效果，用AS3的graphics就可畫出來，而且應該用不到2MB吧！

附件02_Interop.rar

破晓 · 发表于 2015-1-4 17:35:30

Crossbridge sample 02 Interop 分析 hellointerop.c

開啟 hellointerop.c

#include <stdio.h>
#include <string.h>
#include "AS3/AS3.h"
int main(int argc, char **argv)
{
// flascc uses GCC's inline asm syntax to allow you to write arbitrary
// ActionScript inside your C/C++ code. This allows for very easy interop
// between AS3 and C/C++.
// flascc 使用 GCC 的行內組合語言語法，允許你寫任意的 ActionScript 到
// 你的 C/C++ 代碼內。這樣可以非常容易的交互操作於 AS3 和 C/C++之間。
//
// For a complete guide to the asm statement and how it is used read the
// GCC documentation: [url=http://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html]http://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html[/url]
// or: [url]http://www.ibiblio.org/gferg/ldp/GCC-Inline-Assembly-HOWTO.html[/url]
// 完整的組合語言敘述句引導，並且如何使用之，請參閱 GCC 文檔:
// [url]http://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html[/url][/url] 或:
// [url]http://www.ibiblio.org/gferg/ldp/GCC-Inline-Assembly-HOWTO.html[/url][/url]
//
// Behind the scenes flascc turns each function/method in your C/C++ code
// into an AS3 function. The only reason for mentioning this is that this
// of course limits what AS3 you can put in an inline asm statement inside
// a function. You can't write an AS3 class declaration inside an inline
// asm statement inside a C/C++ function. You can however write a class
// declaration outside any C/C++ function.
// flascc 在幕後把每個 C/C++代碼的函數/方法轉成 AS3 的函數。提到這點
// 的目的是因為，這理所當然限制了你可以放在行內組合語言敘述句的 AS3
// 你不能在 C/C++ 函數內的行內組合語言敘述句寫 AS3 類宣告。然而你
// 可以在任何 C/C++ 函數外面寫類宣告。
// The following asm statment declares an AS3 variable and traces it out.
// Because this asm statement doesn't mention any output parameters it must
// be marked as volatile or GCC will optimise it away.
// 以下的組合語言敘述句宣告一個 AS3 變數，並且 trace 之。
// 因為此組合語言敘述句沒有提到任何標記為 volatile 變數的輸出參數，所以
// GCC 將會優化之。
//
// Note: This will not be visible in the SWF console; trace() output goes to
// the flashlog file. For more information on how to enable trace output
// visit: [url]http://kb2.adobe.com/cps/403/kb403009.html[/url][/url]
// 注意: 無法在 SWF 控制台看到此輸出; trace() 輸出進到 flashlog 檔案。
// 關於如何能 trace 輸出的更多資訊，請參閱
// [url]http://kb2.adobe.com/cps/403/kb403009.html[/url][/url]
inline_as3(
"var foo:int = 42;\n"
"trace(\"This is inline AS3: \" + foo);\n"
: :
);
// asm statements can take input and output parameters like this. This
// allows for very easy interop between the two languages.
// 組合語言敘述句能夠像此一樣獲得輸入和輸出。此允許兩個語言間很容易
// 的交互操作。
//
// Not all C/C++ types have an equivalent in actionscript. They are mapped
// as follows:
// 並非所有的 C/C++ 類型在 actionscript 都有等價之類型。其映射如下：
//
// C Type | AS3 Type
// 32bit int | int
// 64bit int | special handling required! 需要特別處理!
// 32bit float | Number
// 64bit double | Number
// pointer | int
// Use AS3 to negate a 32bit int!
// 使用 AS3 把 32 位元 int 變成負數
int someint = 123;
int intresult = 0;
inline_as3(
//指定%0為負的%1
"%0 = -%1;\n"
//%0是intersult
: "=r"(intresult)
//%1是someint
: "r"(someint)
);
// Back in C we can take the result and print it out:
//回到 C 獲得結果並輸出之
printf("-%d is %d\n", someint, intresult);
// Use AS3 to sqrt a double!
// 使用 AS3 把雙精度浮點數開根號
double somenumber = 45.0;
double result = 0.0;
inline_as3(
//把%1開根號指定給%0
"%0 = Math.sqrt(%1);\n"
//%0 是 result，%1 是 somenumber
: "=r"(result) : "r"(somenumber)
);
// Back in C we can take the result and print it out:
// 回到 C 獲得結果並輸出之
printf("sqrt of %f is %f\n", somenumber, result);
// Use AS3 to manipulate a 64bit int!
// 使用 AS3 操作 64位元整數
unsigned long long somelonglong = 0x243F6A8885A308D3ULL; // 64 fractional pi bits 64位元的PI小數部份
double piapprox = 0.0;
inline_as3(
// cast to uint because %1 and %2 will be AS3 int despite "unsigned" C expression type
// 雖然 C 表態式類型是"unsigned"，還是要強制轉型成 uint，因為%1和%2是 AS3 的 int。
"%0 = 3 + uint(%1) / 0x100000000 + uint(%2) / 0x10000000000000000\n"
: "=r"(piapprox) : "r"((unsigned)(somelonglong >> 32)), "r"((unsigned)somelonglong));
printf("pi approx is %.15f\n", piapprox);
// Now, 64-bit out
// 現在試試 64位元
unsigned hi32, lo32;
inline_as3(
"%0 = uint(Math.sqrt(2) * 0x100000000); %1 = uint(Math.sqrt(2) * 0x10000000000000000)\n"
: "=r"(hi32), "=r"(lo32));
somelonglong = ((unsigned long long)hi32 << 32) | lo32;
// 輸出根號2的52位尾數是
printf("52 fractional bits of sqrt(2): %llx\n", somelonglong); // only 52 bit mantissa in double! 在 double 只有 52位尾數
// Handling C strings involves a bit more work. Although they aren't
// automatically converted to AS3 String objects when passed in/out of an
// asm statement there are helper methods available.
// 處理 C 字串要做更多事。雖然其不是自動轉成 AS3 字串物件，不過當傳遞
// 進出於組合語言表態式時，有輔助方法。
const char* words[] = {"flascc", "is", "awesome!"};
int i;
for(i=0; i<3; i++) {
inline_as3(
"trace(\"trace: \" + %0 + \": \" + CModule.readString(%1, %2));\n"
: : "r"(i), "r"(words[i]), "r"(strlen(words[i]))
);
}
// What about passing strings from AS3 into C/C++? Because flascc uses a
// ByteArray for storage we need to malloc() some space in that ByteArray
// and copy the string data in.
// 那要如何從 AS3 傳遞字串到 C/C++呢？因為 flascc 使用一個 ByteArray
// 來儲存，我們需要在該ByteArray malloc() 一些空間，並從中拷貝字串。
//
// The mallocString helper function takes an AS3 string and allocates a
// copy in the flascc heap. This can then be freed from C using the
// normal free() function.
// 此 mallocString 輔助函數，要一個 AS3 字串，並且在 flascc 堆分配
// 一個拷貝。這樣就可以在 C 使用 free() 函數釋放之。
//
// This example also shows that variables declared in one asm block are
// visible to other asm blocks.
// 此範例展示在一個組合語言區塊的變數宣告，改變數在其它組合語言區塊可見。
inline_as3("var as3words = ['Interop', 'is', 'easy!'];\n");
char* wordptrs[] = {NULL, NULL, NULL};
for(i=0; i<3; i++) {
inline_as3(
"var stringptr:int = CModule.mallocString(as3words[%0]);\n"
"CModule.write32(%1, stringptr);\n"
: : "r"(i), "r"(&wordptrs[i])
);
}
for(i=0; i<3; i++) {
printf(">>> %s\n", wordptrs[i]);
free(wordptrs[i]);
}
}

复制代码

名詞解釋
interop 交互操作，應該是 inter 和 operation 的結合。
volatile 變數，用於 C 的變數關鍵字，使 C 編譯器不優化該變數。

破晓 · 发表于 2015-1-4 17:36:36

Crossbridge sample 02 Interop 分析 c++interop.cpp
再來讓我們來看一下 c++interop.cpp

#include <vector>
#include <AS3/AS3.h>
#include <Flash++.h>
// Flash 11.4 introduced a worker-based concurrency model in which each worker
// has access to almost all of the Flash APIs with the one restriction that
// objects on one worker cannot be passed to other workers, all communication
// must happen via special communication APIs (MessageChannel) or via the
// shared ByteArray support (Flash 11.5)
// Flash 11.4 引進了以線程為基礎的並行處理模型，在每一個線程幾乎可以使用
// 所有的 Flash API ，不過有一個限制，一個線程內的物件無法傳遞給其他線程，
// 所有的溝通必須經由特殊的溝通 API(MessageChannel) 或
// 經由 Flash 11.5 支持的共享 ByteArray。
//
// Flash++ contains two sets of bindings for the flash APIs, one that refers to
// objects on the UI worker (the main flash instance that has access to the
// primary display) and another that refers to objects local to a given worker.
// Flash++ 包涵兩個 flash API 的結合設定，其一代表在 UI 線程物件(主
// Flash 實例，其用來做主要顯示)，其二代表給定的本地線程物件。
//
// When interacting with "ui" references property access and method calls will
// block until they can be serviced by the main worker when it calls
// CModule.serviceUIRequests() (Which it should be doing on EnterFrame, or on a
// timer).
// 當存取 "ui" 參考屬性，和呼叫方法時，可能會造成阻塞，只有在呼叫
// CModule.serviceUIRequests() (應該用在 EnterFrame 或 timer)，它們才可以服務
// 主線程。
//
// Because we will just be using UI references in this example we can avoid the
// need to type the additional "AS3::ui" prefix with a normal C++ using
// declaration.
// 因為我們在此範例將剛好使用 UI 參考，只需於正常的 C++ 輸入 "AS3::ui" 前綴宣告，
// 我們就可以避免此狀況。
using namespace AS3::ui;
// using namespace AS3::local;
// if we wanted everything to be worker-local
// 如果我們想要在本地線程的東西，則using namespace AS3::local;
int main()
{
// Get a reference to the current stage
// 獲得目前舞台參考
flash::display::Stage stage = internal::get_Stage();
// Just to prove we can lets make a C++ vector containing sprite references
// 證明我們可以讓 C++ vector 持有 sprite 參考
std::vector<flash::display::Sprite> sprites;
int numCircles = 10;
for(int i=0; i<numCircles; i++) {
// Construct a new Sprite object
// 建構一個新的 Sprite 物件
flash::display::Sprite mySprite = flash::display::Sprite::_new();
// Access its "graphics" property to get the canvas we can draw to
// 存取其 "graphics" 屬性，來獲得可以畫畫的畫板。
flash::display::Graphics graphics = mySprite->graphics;
// Draw simple filled circle
// 畫簡單的填色圓形
graphics->beginFill(0xff00ff, 0.5);
graphics->drawCircle(0.0, 0.0, 30.0);
graphics->endFill();
// Add the sprite into our C++ vector
// 把 sprite 加入到 C++ vector
sprites.push_back(mySprite);
}
// Add the circles to the stage
// 把圓形加到舞台
for(int i=0; i<numCircles; i++) {
// Take one of the sprites and position it along the diagonal of
// the screen
// 獲得其中一個 sprite ，並沿著螢幕的對角線擺放
flash::display::Sprite s = sprites[i];
s->x = i * 25;
s->y = i * 25;
// Add it to the stage so we can see it
// 將其加入到舞台，使我們可以看見之
stage->addChild(s);
}
}

复制代码

也就是說
AS3
import flash.display.Sprite;
var mySprite = new Sprite();
在 Flash++ 要寫成
flash::display::Sprite mySprite = flash::display::Sprite::_new();

AS3
mySprite.graphics.beginFill(0xff00ff, 0.5)
在 Flash++ 要寫成
flash::display::Graphics graphics = mySprite->graphics;
graphics->beginFill(0xff00ff, 0.5);

破晓 · 发表于 2015-1-4 17:44:26

Crossbridge sample 02 Interop 分析 bitmapdata.cpp

最後來看一下 bitmapdata.cpp

#include <AS3/AS3.h>
#include <Flash++.h>
// Flash 11.4 introduced a worker-based concurrency model in which each worker
// has access to almost all of the Flash APIs with the one restriction that
// objects on one worker cannot be passed to other workers, all communication
// must happen via special communication APIs (MessageChannel) or via the
// shared ByteArray support (Flash 11.5)
// Flash 11.4 引進了以線程為基礎的並行處理模型，在每一個線程幾乎可以使用
// 所有的 Flash API ，不過有一個限制，一個線程內的物件無法傳遞給其他線程，
// 所有的溝通必須經由特殊的溝通 API(MessageChannel) 或
// 經由 Flash 11.5 支持的共享 ByteArray。
//
// Flash++ contains two sets of bindings for the flash APIs, one that refers to
// objects on the UI worker (the main flash instance that has access to the
// primary display) and another that refers to objects local to a given worker.
// Flash++ 包涵兩個 flash API 的結合設定，其一代表在 UI 線程物件(主
// Flash 實例，其用來做主要顯示)，其二代表給定的本地線程物件。
//
// When interacting with "ui" references property access and method calls will
// block until they can be serviced by the main worker when it calls
// CModule.serviceUIRequests() (Which it should be doing on EnterFrame, or on a
// timer).
// 當存取 "ui" 參考屬性，和呼叫方法時，可能會造成阻塞，只有在呼叫
// CModule.serviceUIRequests() (應該用在 EnterFrame 或 timer)，它們才可以服務
// 主線程。
//
// Because we will just be using UI references in this example we can avoid the
// need to type the additional "AS3::ui" prefix with a normal C++ using
// declaration.
// 因為我們在此範例將剛好使用 UI 參考，只需於正常的 C++ 輸入 "AS3::ui" 前綴宣告，
// 我們就可以避免此狀況。
using namespace AS3::ui;
// using namespace AS3::local; // if we wanted everything to be worker-local
// 如果我們想要在本地線程的東西，則using namespace AS3::local;
static const int COORDBITS = 7; // 7 bits => dim of 128 7位是128的dim(模糊不清)
static const int DIM = 1 << COORDBITS; //CORRDBITS精度位
// return a "swizzled" (Morton order -- x/y bits interleaved) offset
// for a given input offset and coordinate bit count
// 對於給定的輸入位移，整合位元計算後，返回 "swizzled(攪和的)"
// (摩頓順序 -- x/y 位交错) 位移值
static int swizzleOffset(int offs)
{
int result = 0;
int coordBits = COORDBITS;
int offsHi = offs >> COORDBITS; // take the higher order bits 獲得更高的位元
int coordBits2 = COORDBITS * 2;
while(coordBits--)
{
// put the lowest bit in the "lo" offset bits
// into the highest bit of the result...
// it'll get shifted into a lower position
// as the loop executes
// 把在 "lo" offset 位元的最低位放到結果的最高位
// 當迴圈執行時，其將移到更低的位子
result |= ((offs & 1) << coordBits2);
offs >>= 1;
result >>= 1;
// same for the "hi" offset bits
// 至於 "hi" 位移位元也一樣
result |= ((offsHi & 1) << coordBits2);
offsHi >>= 1;
result >>= 1;
}
return result;
}
// swizzle a whole image worth of pixels
// 攪和整個圖片的等值像素
static void swizzlePixels(unsigned *dst, unsigned *src)
{
int offs = DIM * DIM;
while(offs--)
{
int swiz = swizzleOffset(offs);
dst[swiz] = src[offs];
}
}
// handle a mouse click and swizzle our BitmapData's pixels
// 處理滑鼠點擊，並攪和位圖資料的像素
static var mouseDownHandler(void *arg, var args)
{
flash::events::MouseEvent event = flash::events::MouseEvent(args[0]);
flash::display::Sprite sprite = flash::display::Sprite(event->target); // the container Sprite Sprite容器
flash::display::Bitmap bitmap = flash::display::Bitmap(sprite->getChildAt(0)); // Bitmap is the only child 位圖是唯一的子物件
flash::display::BitmapData bitmapData = bitmap->bitmapData;
// ByteArray corresponding to our ram!
// C ptrs are equivalent to offsets into this ByteArray
// ByteArray 對應到記憶體！
// C 指標等同於進到此 ByteArray 的 offsets
flash::utils::ByteArray ram = internal::get_ram();
// allocate space for the pixels
// 為像素分配空間
unsigned *src = new unsigned[DIM * DIM];
unsigned *dst = new unsigned[DIM * DIM];
// copy current pixels directly to ram
// 直接拷貝目前的像素到記憶體
bitmapData->copyPixelsToByteArray(bitmapData->rect, ram, src);
// swizzle them!
// 攪和它們！
swizzlePixels(dst, src);
// write new pixels directly from ram
// 直接從記憶體寫新的像素
bitmapData->setPixels(bitmapData->rect, ram, dst);
// clean up
// 清除
delete dst;
delete src;
return internal::_undefined;
}
int main()
{
// Get a reference to the current stage
// 獲得目前舞台參考
flash::display::Stage stage = internal::get_Stage();
// Create a Shape
// 創建一個 Shape
flash::display::Shape myShape = flash::display::Shape::_new();
// Access its "graphics" property to get the canvas we can draw to
// 訪問其 "graphics" 屬性，獲得可畫畫的畫板
flash::display::Graphics graphics = myShape->graphics;
// Draw simple shape
// 畫簡單圖形
graphics->beginFill(0xff00ff, 0.5);
graphics->drawCircle(64.0, 64.0, 64.0);
graphics->endFill();
graphics->beginFill(0xffff00, 0.5);
graphics->drawCircle(64.0, 64.0, 40.0);
graphics->endFill();
graphics->beginFill(0x00ffff, 0.5);
graphics->drawCircle(64.0, 64.0, 16.0);
graphics->endFill();
// Create a BitmapData
// 創建一個 BitmapData
flash::display::BitmapData myBitmapData = flash::display::BitmapData::_new(DIM, DIM);
// Draw the Shape into it
// 把 Shape 畫到裡面
myBitmapData->draw(myShape);
// Create a Bitmap
// 創建一個 Bitmap
flash::display::Bitmap myBitmap = flash::display::Bitmap::_new(myBitmapData);
// wrap it in a Sprite
// 創建一個 Sprite，並把 Bitmap 放進去
flash::display::Sprite mySprite = flash::display::Sprite::_new();
mySprite->addChild(myBitmap);
// Add a click handler
// 添加點擊處理
mySprite->addEventListener("mouseDown", Function::_new(&mouseDownHandler, NULL));
// Add it to the stage so we can see it
// 把它加到舞台，使我等可以看見之
stage->addChild(mySprite);
// Go async so we can handle the mouseDowns!
// 到異步，以便吾人可以處理滑鼠按下！
AS3_GoAsync();
// Not reached!
// 不會到達！
return 0;
}